
bin/kernel:     file format elf32-i386


Disassembly of section .text:

00100000 <kern_init>:
#include <clock.h>

int kern_init(void) __attribute__((noreturn));

int
kern_init(void) {
  100000:	55                   	push   %ebp
  100001:	89 e5                	mov    %esp,%ebp
  100003:	83 ec 28             	sub    $0x28,%esp
	extern char edata[], end[];
	memset(edata, 0, end - edata);
  100006:	ba 64 e8 10 00       	mov    $0x10e864,%edx
  10000b:	b8 e0 d9 10 00       	mov    $0x10d9e0,%eax
  100010:	89 d1                	mov    %edx,%ecx
  100012:	29 c1                	sub    %eax,%ecx
  100014:	89 c8                	mov    %ecx,%eax
  100016:	89 44 24 08          	mov    %eax,0x8(%esp)
  10001a:	c7 44 24 04 00 00 00 	movl   $0x0,0x4(%esp)
  100021:	00 
  100022:	c7 04 24 e0 d9 10 00 	movl   $0x10d9e0,(%esp)
  100029:	e8 fd 2e 00 00       	call   102f2b <memset>

	cons_init();				// init the console
  10002e:	e8 af 12 00 00       	call   1012e2 <cons_init>

	const char *message = "(THU.CST) os is loading ...";
  100033:	c7 45 f4 c0 30 10 00 	movl   $0x1030c0,-0xc(%ebp)
	cprintf("%s\n\n", message);
  10003a:	8b 45 f4             	mov    -0xc(%ebp),%eax
  10003d:	89 44 24 04          	mov    %eax,0x4(%esp)
  100041:	c7 04 24 dc 30 10 00 	movl   $0x1030dc,(%esp)
  100048:	e8 23 01 00 00       	call   100170 <cprintf>

	print_kerninfo();
  10004d:	e8 2e 06 00 00       	call   100680 <print_kerninfo>

	pic_init();					// init interrupt controller
  100052:	e8 ca 13 00 00       	call   101421 <pic_init>
	idt_init();					// init interrupt descriptor table
  100057:	e8 42 15 00 00       	call   10159e <idt_init>

	clock_init();				// init clock interrupt
  10005c:	e8 6b 0a 00 00       	call   100acc <clock_init>
	asm volatile ("lidt (%0)" :: "r" (pd));
}

static inline void
sti(void) {
	asm volatile ("sti");
  100061:	fb                   	sti    

	sti();						// enable irq interrupt

	/* do nothing */
	while (1);
  100062:	eb fe                	jmp    100062 <kern_init+0x62>

00100064 <readline>:
 * The readline() function returns the text of the line read. If some errors
 * are happened, NULL is returned. The return value is a global variable,
 * thus it should be copied before it is used.
 * */
char *
readline(const char *prompt) {
  100064:	55                   	push   %ebp
  100065:	89 e5                	mov    %esp,%ebp
  100067:	83 ec 28             	sub    $0x28,%esp
	if (prompt != NULL) {
  10006a:	83 7d 08 00          	cmpl   $0x0,0x8(%ebp)
  10006e:	74 13                	je     100083 <readline+0x1f>
		cprintf("%s", prompt);
  100070:	8b 45 08             	mov    0x8(%ebp),%eax
  100073:	89 44 24 04          	mov    %eax,0x4(%esp)
  100077:	c7 04 24 e1 30 10 00 	movl   $0x1030e1,(%esp)
  10007e:	e8 ed 00 00 00       	call   100170 <cprintf>
	}
	int i = 0, c;
  100083:	c7 45 f0 00 00 00 00 	movl   $0x0,-0x10(%ebp)
  10008a:	eb 01                	jmp    10008d <readline+0x29>
		else if (c == '\n' || c == '\r') {
			cputchar(c);
			buf[i] = '\0';
			return buf;
		}
	}
  10008c:	90                   	nop
	if (prompt != NULL) {
		cprintf("%s", prompt);
	}
	int i = 0, c;
	while (1) {
		c = getchar();
  10008d:	e8 6c 01 00 00       	call   1001fe <getchar>
  100092:	89 45 f4             	mov    %eax,-0xc(%ebp)
		if (c < 0) {
  100095:	83 7d f4 00          	cmpl   $0x0,-0xc(%ebp)
  100099:	79 07                	jns    1000a2 <readline+0x3e>
			return NULL;
  10009b:	b8 00 00 00 00       	mov    $0x0,%eax
  1000a0:	eb 76                	jmp    100118 <readline+0xb4>
		}
		else if (c >= ' ' && i < BUFSIZE - 1) {
  1000a2:	83 7d f4 1f          	cmpl   $0x1f,-0xc(%ebp)
  1000a6:	7e 26                	jle    1000ce <readline+0x6a>
  1000a8:	81 7d f0 fe 03 00 00 	cmpl   $0x3fe,-0x10(%ebp)
  1000af:	7f 1d                	jg     1000ce <readline+0x6a>
			cputchar(c);
  1000b1:	8b 45 f4             	mov    -0xc(%ebp),%eax
  1000b4:	89 04 24             	mov    %eax,(%esp)
  1000b7:	e8 dd 00 00 00       	call   100199 <cputchar>
			buf[i ++] = c;
  1000bc:	8b 45 f0             	mov    -0x10(%ebp),%eax
  1000bf:	8b 55 f4             	mov    -0xc(%ebp),%edx
  1000c2:	88 90 e0 d9 10 00    	mov    %dl,0x10d9e0(%eax)
  1000c8:	83 45 f0 01          	addl   $0x1,-0x10(%ebp)
	while (1) {
		c = getchar();
		if (c < 0) {
			return NULL;
		}
		else if (c >= ' ' && i < BUFSIZE - 1) {
  1000cc:	eb 45                	jmp    100113 <readline+0xaf>
			cputchar(c);
			buf[i ++] = c;
		}
		else if (c == '\b' && i > 0) {
  1000ce:	83 7d f4 08          	cmpl   $0x8,-0xc(%ebp)
  1000d2:	75 17                	jne    1000eb <readline+0x87>
  1000d4:	83 7d f0 00          	cmpl   $0x0,-0x10(%ebp)
  1000d8:	7e 11                	jle    1000eb <readline+0x87>
			cputchar(c);
  1000da:	8b 45 f4             	mov    -0xc(%ebp),%eax
  1000dd:	89 04 24             	mov    %eax,(%esp)
  1000e0:	e8 b4 00 00 00       	call   100199 <cputchar>
			i --;
  1000e5:	83 6d f0 01          	subl   $0x1,-0x10(%ebp)
		}
		else if (c >= ' ' && i < BUFSIZE - 1) {
			cputchar(c);
			buf[i ++] = c;
		}
		else if (c == '\b' && i > 0) {
  1000e9:	eb 28                	jmp    100113 <readline+0xaf>
			cputchar(c);
			i --;
		}
		else if (c == '\n' || c == '\r') {
  1000eb:	83 7d f4 0a          	cmpl   $0xa,-0xc(%ebp)
  1000ef:	74 06                	je     1000f7 <readline+0x93>
  1000f1:	83 7d f4 0d          	cmpl   $0xd,-0xc(%ebp)
  1000f5:	75 95                	jne    10008c <readline+0x28>
			cputchar(c);
  1000f7:	8b 45 f4             	mov    -0xc(%ebp),%eax
  1000fa:	89 04 24             	mov    %eax,(%esp)
  1000fd:	e8 97 00 00 00       	call   100199 <cputchar>
			buf[i] = '\0';
  100102:	8b 45 f0             	mov    -0x10(%ebp),%eax
  100105:	c6 80 e0 d9 10 00 00 	movb   $0x0,0x10d9e0(%eax)
			return buf;
  10010c:	b8 e0 d9 10 00       	mov    $0x10d9e0,%eax
  100111:	eb 05                	jmp    100118 <readline+0xb4>
		}
	}
  100113:	e9 75 ff ff ff       	jmp    10008d <readline+0x29>
}
  100118:	c9                   	leave  
  100119:	c3                   	ret    
	...

0010011c <cputch>:
/* *
 * cputch - writes a single character @c to stdout, and it will
 * increace the value of counter pointed by @cnt.
 * */
static void
cputch(int c, int *cnt) {
  10011c:	55                   	push   %ebp
  10011d:	89 e5                	mov    %esp,%ebp
  10011f:	83 ec 18             	sub    $0x18,%esp
	cons_putc(c);
  100122:	8b 45 08             	mov    0x8(%ebp),%eax
  100125:	89 04 24             	mov    %eax,(%esp)
  100128:	e8 e1 11 00 00       	call   10130e <cons_putc>
	(*cnt) ++;
  10012d:	8b 45 0c             	mov    0xc(%ebp),%eax
  100130:	8b 00                	mov    (%eax),%eax
  100132:	8d 50 01             	lea    0x1(%eax),%edx
  100135:	8b 45 0c             	mov    0xc(%ebp),%eax
  100138:	89 10                	mov    %edx,(%eax)
}
  10013a:	c9                   	leave  
  10013b:	c3                   	ret    

0010013c <vcprintf>:
 *
 * Call this function if you are already dealing with a va_list.
 * Or you probably want cprintf() instead.
 * */
int
vcprintf(const char *fmt, va_list ap) {
  10013c:	55                   	push   %ebp
  10013d:	89 e5                	mov    %esp,%ebp
  10013f:	83 ec 28             	sub    $0x28,%esp
	int cnt = 0;
  100142:	c7 45 f4 00 00 00 00 	movl   $0x0,-0xc(%ebp)
	vprintfmt((void*)cputch, &cnt, fmt, ap);
  100149:	b8 1c 01 10 00       	mov    $0x10011c,%eax
  10014e:	8b 55 0c             	mov    0xc(%ebp),%edx
  100151:	89 54 24 0c          	mov    %edx,0xc(%esp)
  100155:	8b 55 08             	mov    0x8(%ebp),%edx
  100158:	89 54 24 08          	mov    %edx,0x8(%esp)
  10015c:	8d 55 f4             	lea    -0xc(%ebp),%edx
  10015f:	89 54 24 04          	mov    %edx,0x4(%esp)
  100163:	89 04 24             	mov    %eax,(%esp)
  100166:	e8 9c 25 00 00       	call   102707 <vprintfmt>
	return cnt;
  10016b:	8b 45 f4             	mov    -0xc(%ebp),%eax
}
  10016e:	c9                   	leave  
  10016f:	c3                   	ret    

00100170 <cprintf>:
 *
 * The return value is the number of characters which would be
 * written to stdout.
 * */
int
cprintf(const char *fmt, ...) {
  100170:	55                   	push   %ebp
  100171:	89 e5                	mov    %esp,%ebp
  100173:	83 ec 28             	sub    $0x28,%esp
	va_list ap;
	int cnt;
	va_start(ap, fmt);
  100176:	8d 45 08             	lea    0x8(%ebp),%eax
  100179:	83 c0 04             	add    $0x4,%eax
  10017c:	89 45 f0             	mov    %eax,-0x10(%ebp)
	cnt = vcprintf(fmt, ap);
  10017f:	8b 45 08             	mov    0x8(%ebp),%eax
  100182:	8b 55 f0             	mov    -0x10(%ebp),%edx
  100185:	89 54 24 04          	mov    %edx,0x4(%esp)
  100189:	89 04 24             	mov    %eax,(%esp)
  10018c:	e8 ab ff ff ff       	call   10013c <vcprintf>
  100191:	89 45 f4             	mov    %eax,-0xc(%ebp)
	va_end(ap);
	return cnt;
  100194:	8b 45 f4             	mov    -0xc(%ebp),%eax
}
  100197:	c9                   	leave  
  100198:	c3                   	ret    

00100199 <cputchar>:

/* cputchar - writes a single character to stdout */
void
cputchar(int c) {
  100199:	55                   	push   %ebp
  10019a:	89 e5                	mov    %esp,%ebp
  10019c:	83 ec 18             	sub    $0x18,%esp
	cons_putc(c);
  10019f:	8b 45 08             	mov    0x8(%ebp),%eax
  1001a2:	89 04 24             	mov    %eax,(%esp)
  1001a5:	e8 64 11 00 00       	call   10130e <cons_putc>
}
  1001aa:	c9                   	leave  
  1001ab:	c3                   	ret    

001001ac <cputs>:
/* *
 * cputs- writes the string pointed by @str to stdout and
 * appends a newline character.
 * */
int
cputs(const char *str) {
  1001ac:	55                   	push   %ebp
  1001ad:	89 e5                	mov    %esp,%ebp
  1001af:	83 ec 28             	sub    $0x28,%esp
	int cnt = 0;
  1001b2:	c7 45 f0 00 00 00 00 	movl   $0x0,-0x10(%ebp)
	char c;
	while ((c = *str ++) != '\0') {
  1001b9:	eb 13                	jmp    1001ce <cputs+0x22>
		cputch(c, &cnt);
  1001bb:	0f be 45 f7          	movsbl -0x9(%ebp),%eax
  1001bf:	8d 55 f0             	lea    -0x10(%ebp),%edx
  1001c2:	89 54 24 04          	mov    %edx,0x4(%esp)
  1001c6:	89 04 24             	mov    %eax,(%esp)
  1001c9:	e8 4e ff ff ff       	call   10011c <cputch>
 * */
int
cputs(const char *str) {
	int cnt = 0;
	char c;
	while ((c = *str ++) != '\0') {
  1001ce:	8b 45 08             	mov    0x8(%ebp),%eax
  1001d1:	0f b6 00             	movzbl (%eax),%eax
  1001d4:	88 45 f7             	mov    %al,-0x9(%ebp)
  1001d7:	80 7d f7 00          	cmpb   $0x0,-0x9(%ebp)
  1001db:	0f 95 c0             	setne  %al
  1001de:	83 45 08 01          	addl   $0x1,0x8(%ebp)
  1001e2:	84 c0                	test   %al,%al
  1001e4:	75 d5                	jne    1001bb <cputs+0xf>
		cputch(c, &cnt);
	}
	cputch('\n', &cnt);
  1001e6:	8d 45 f0             	lea    -0x10(%ebp),%eax
  1001e9:	89 44 24 04          	mov    %eax,0x4(%esp)
  1001ed:	c7 04 24 0a 00 00 00 	movl   $0xa,(%esp)
  1001f4:	e8 23 ff ff ff       	call   10011c <cputch>
	return cnt;
  1001f9:	8b 45 f0             	mov    -0x10(%ebp),%eax
}
  1001fc:	c9                   	leave  
  1001fd:	c3                   	ret    

001001fe <getchar>:

/* getchar - reads a single non-zero character from stdin */
int
getchar(void) {
  1001fe:	55                   	push   %ebp
  1001ff:	89 e5                	mov    %esp,%ebp
  100201:	83 ec 18             	sub    $0x18,%esp
	int c;
	while ((c = cons_getc()) == 0)
  100204:	e8 2e 11 00 00       	call   101337 <cons_getc>
  100209:	89 45 f4             	mov    %eax,-0xc(%ebp)
  10020c:	83 7d f4 00          	cmpl   $0x0,-0xc(%ebp)
  100210:	74 f2                	je     100204 <getchar+0x6>
		/* do nothing */;
	return c;
  100212:	8b 45 f4             	mov    -0xc(%ebp),%eax
}
  100215:	c9                   	leave  
  100216:	c3                   	ret    
	...

00100218 <stab_binsearch>:
 *      stab_binsearch(stabs, &left, &right, N_SO, 0xf0100184);
 * will exit setting left = 118, right = 554.
 * */
static void
stab_binsearch(const struct stab *stabs, int *region_left, int *region_right,
	       int type, uintptr_t addr) {
  100218:	55                   	push   %ebp
  100219:	89 e5                	mov    %esp,%ebp
  10021b:	83 ec 20             	sub    $0x20,%esp
	int l = *region_left, r = *region_right, any_matches = 0;
  10021e:	8b 45 0c             	mov    0xc(%ebp),%eax
  100221:	8b 00                	mov    (%eax),%eax
  100223:	89 45 ec             	mov    %eax,-0x14(%ebp)
  100226:	8b 45 10             	mov    0x10(%ebp),%eax
  100229:	8b 00                	mov    (%eax),%eax
  10022b:	89 45 f0             	mov    %eax,-0x10(%ebp)
  10022e:	c7 45 f4 00 00 00 00 	movl   $0x0,-0xc(%ebp)

	while (l <= r) {
  100235:	e9 c8 00 00 00       	jmp    100302 <stab_binsearch+0xea>
		int true_m = (l + r) / 2, m = true_m;
  10023a:	8b 45 f0             	mov    -0x10(%ebp),%eax
  10023d:	8b 55 ec             	mov    -0x14(%ebp),%edx
  100240:	8d 04 02             	lea    (%edx,%eax,1),%eax
  100243:	89 c2                	mov    %eax,%edx
  100245:	c1 ea 1f             	shr    $0x1f,%edx
  100248:	8d 04 02             	lea    (%edx,%eax,1),%eax
  10024b:	d1 f8                	sar    %eax
  10024d:	89 45 f8             	mov    %eax,-0x8(%ebp)
  100250:	8b 45 f8             	mov    -0x8(%ebp),%eax
  100253:	89 45 fc             	mov    %eax,-0x4(%ebp)

		// search for earliest stab with right type
		while (m >= l && stabs[m].n_type != type) {
  100256:	eb 04                	jmp    10025c <stab_binsearch+0x44>
			m --;
  100258:	83 6d fc 01          	subl   $0x1,-0x4(%ebp)

	while (l <= r) {
		int true_m = (l + r) / 2, m = true_m;

		// search for earliest stab with right type
		while (m >= l && stabs[m].n_type != type) {
  10025c:	8b 45 fc             	mov    -0x4(%ebp),%eax
  10025f:	3b 45 ec             	cmp    -0x14(%ebp),%eax
  100262:	7c 1b                	jl     10027f <stab_binsearch+0x67>
  100264:	8b 55 fc             	mov    -0x4(%ebp),%edx
  100267:	89 d0                	mov    %edx,%eax
  100269:	01 c0                	add    %eax,%eax
  10026b:	01 d0                	add    %edx,%eax
  10026d:	c1 e0 02             	shl    $0x2,%eax
  100270:	03 45 08             	add    0x8(%ebp),%eax
  100273:	0f b6 40 04          	movzbl 0x4(%eax),%eax
  100277:	0f b6 c0             	movzbl %al,%eax
  10027a:	3b 45 14             	cmp    0x14(%ebp),%eax
  10027d:	75 d9                	jne    100258 <stab_binsearch+0x40>
			m --;
		}
		if (m < l) {	// no match in [l, m]
  10027f:	8b 45 fc             	mov    -0x4(%ebp),%eax
  100282:	3b 45 ec             	cmp    -0x14(%ebp),%eax
  100285:	7d 0b                	jge    100292 <stab_binsearch+0x7a>
			l = true_m + 1;
  100287:	8b 45 f8             	mov    -0x8(%ebp),%eax
  10028a:	83 c0 01             	add    $0x1,%eax
  10028d:	89 45 ec             	mov    %eax,-0x14(%ebp)
			continue;
  100290:	eb 70                	jmp    100302 <stab_binsearch+0xea>
		}

		// actual binary search
		any_matches = 1;
  100292:	c7 45 f4 01 00 00 00 	movl   $0x1,-0xc(%ebp)
		if (stabs[m].n_value < addr) {
  100299:	8b 55 fc             	mov    -0x4(%ebp),%edx
  10029c:	89 d0                	mov    %edx,%eax
  10029e:	01 c0                	add    %eax,%eax
  1002a0:	01 d0                	add    %edx,%eax
  1002a2:	c1 e0 02             	shl    $0x2,%eax
  1002a5:	03 45 08             	add    0x8(%ebp),%eax
  1002a8:	8b 40 08             	mov    0x8(%eax),%eax
  1002ab:	3b 45 18             	cmp    0x18(%ebp),%eax
  1002ae:	73 13                	jae    1002c3 <stab_binsearch+0xab>
			*region_left = m;
  1002b0:	8b 45 0c             	mov    0xc(%ebp),%eax
  1002b3:	8b 55 fc             	mov    -0x4(%ebp),%edx
  1002b6:	89 10                	mov    %edx,(%eax)
			l = true_m + 1;
  1002b8:	8b 45 f8             	mov    -0x8(%ebp),%eax
  1002bb:	83 c0 01             	add    $0x1,%eax
  1002be:	89 45 ec             	mov    %eax,-0x14(%ebp)
  1002c1:	eb 3f                	jmp    100302 <stab_binsearch+0xea>
		} else if (stabs[m].n_value > addr) {
  1002c3:	8b 55 fc             	mov    -0x4(%ebp),%edx
  1002c6:	89 d0                	mov    %edx,%eax
  1002c8:	01 c0                	add    %eax,%eax
  1002ca:	01 d0                	add    %edx,%eax
  1002cc:	c1 e0 02             	shl    $0x2,%eax
  1002cf:	03 45 08             	add    0x8(%ebp),%eax
  1002d2:	8b 40 08             	mov    0x8(%eax),%eax
  1002d5:	3b 45 18             	cmp    0x18(%ebp),%eax
  1002d8:	76 16                	jbe    1002f0 <stab_binsearch+0xd8>
			*region_right = m - 1;
  1002da:	8b 45 fc             	mov    -0x4(%ebp),%eax
  1002dd:	8d 50 ff             	lea    -0x1(%eax),%edx
  1002e0:	8b 45 10             	mov    0x10(%ebp),%eax
  1002e3:	89 10                	mov    %edx,(%eax)
			r = m - 1;
  1002e5:	8b 45 fc             	mov    -0x4(%ebp),%eax
  1002e8:	83 e8 01             	sub    $0x1,%eax
  1002eb:	89 45 f0             	mov    %eax,-0x10(%ebp)
  1002ee:	eb 12                	jmp    100302 <stab_binsearch+0xea>
		} else {
			// exact match for 'addr', but continue loop to find
			// *region_right
			*region_left = m;
  1002f0:	8b 45 0c             	mov    0xc(%ebp),%eax
  1002f3:	8b 55 fc             	mov    -0x4(%ebp),%edx
  1002f6:	89 10                	mov    %edx,(%eax)
			l = m;
  1002f8:	8b 45 fc             	mov    -0x4(%ebp),%eax
  1002fb:	89 45 ec             	mov    %eax,-0x14(%ebp)
			addr ++;
  1002fe:	83 45 18 01          	addl   $0x1,0x18(%ebp)
static void
stab_binsearch(const struct stab *stabs, int *region_left, int *region_right,
	       int type, uintptr_t addr) {
	int l = *region_left, r = *region_right, any_matches = 0;

	while (l <= r) {
  100302:	8b 45 ec             	mov    -0x14(%ebp),%eax
  100305:	3b 45 f0             	cmp    -0x10(%ebp),%eax
  100308:	0f 8e 2c ff ff ff    	jle    10023a <stab_binsearch+0x22>
			l = m;
			addr ++;
		}
	}

	if (!any_matches) {
  10030e:	83 7d f4 00          	cmpl   $0x0,-0xc(%ebp)
  100312:	75 0f                	jne    100323 <stab_binsearch+0x10b>
		*region_right = *region_left - 1;
  100314:	8b 45 0c             	mov    0xc(%ebp),%eax
  100317:	8b 00                	mov    (%eax),%eax
  100319:	8d 50 ff             	lea    -0x1(%eax),%edx
  10031c:	8b 45 10             	mov    0x10(%ebp),%eax
  10031f:	89 10                	mov    %edx,(%eax)
  100321:	eb 3b                	jmp    10035e <stab_binsearch+0x146>
	}
	else {
		// find rightmost region containing 'addr'
		l = *region_right;
  100323:	8b 45 10             	mov    0x10(%ebp),%eax
  100326:	8b 00                	mov    (%eax),%eax
  100328:	89 45 ec             	mov    %eax,-0x14(%ebp)
		for (; l > *region_left && stabs[l].n_type != type; l --)
  10032b:	eb 04                	jmp    100331 <stab_binsearch+0x119>
  10032d:	83 6d ec 01          	subl   $0x1,-0x14(%ebp)
  100331:	8b 45 0c             	mov    0xc(%ebp),%eax
  100334:	8b 00                	mov    (%eax),%eax
  100336:	3b 45 ec             	cmp    -0x14(%ebp),%eax
  100339:	7d 1b                	jge    100356 <stab_binsearch+0x13e>
  10033b:	8b 55 ec             	mov    -0x14(%ebp),%edx
  10033e:	89 d0                	mov    %edx,%eax
  100340:	01 c0                	add    %eax,%eax
  100342:	01 d0                	add    %edx,%eax
  100344:	c1 e0 02             	shl    $0x2,%eax
  100347:	03 45 08             	add    0x8(%ebp),%eax
  10034a:	0f b6 40 04          	movzbl 0x4(%eax),%eax
  10034e:	0f b6 c0             	movzbl %al,%eax
  100351:	3b 45 14             	cmp    0x14(%ebp),%eax
  100354:	75 d7                	jne    10032d <stab_binsearch+0x115>
			/* do nothing */;
		*region_left = l;
  100356:	8b 45 0c             	mov    0xc(%ebp),%eax
  100359:	8b 55 ec             	mov    -0x14(%ebp),%edx
  10035c:	89 10                	mov    %edx,(%eax)
	}
}
  10035e:	c9                   	leave  
  10035f:	c3                   	ret    

00100360 <debuginfo_eip>:
 * the specified instruction address, @addr.  Returns 0 if information
 * was found, and negative if not.  But even if it returns negative it
 * has stored some information into '*info'.
 * */
int
debuginfo_eip(uintptr_t addr, struct eipdebuginfo *info) {
  100360:	55                   	push   %ebp
  100361:	89 e5                	mov    %esp,%ebp
  100363:	53                   	push   %ebx
  100364:	83 ec 54             	sub    $0x54,%esp
	const struct stab *stabs, *stab_end;
	const char *stabstr, *stabstr_end;

	info->eip_file = "<unknown>";
  100367:	8b 45 0c             	mov    0xc(%ebp),%eax
  10036a:	c7 00 e4 30 10 00    	movl   $0x1030e4,(%eax)
	info->eip_line = 0;
  100370:	8b 45 0c             	mov    0xc(%ebp),%eax
  100373:	c7 40 04 00 00 00 00 	movl   $0x0,0x4(%eax)
	info->eip_fn_name = "<unknown>";
  10037a:	8b 45 0c             	mov    0xc(%ebp),%eax
  10037d:	c7 40 08 e4 30 10 00 	movl   $0x1030e4,0x8(%eax)
	info->eip_fn_namelen = 9;
  100384:	8b 45 0c             	mov    0xc(%ebp),%eax
  100387:	c7 40 0c 09 00 00 00 	movl   $0x9,0xc(%eax)
	info->eip_fn_addr = addr;
  10038e:	8b 45 0c             	mov    0xc(%ebp),%eax
  100391:	8b 55 08             	mov    0x8(%ebp),%edx
  100394:	89 50 10             	mov    %edx,0x10(%eax)
	info->eip_fn_narg = 0;
  100397:	8b 45 0c             	mov    0xc(%ebp),%eax
  10039a:	c7 40 14 00 00 00 00 	movl   $0x0,0x14(%eax)

	stabs = __STAB_BEGIN__;
  1003a1:	c7 45 e8 0c 39 10 00 	movl   $0x10390c,-0x18(%ebp)
	stab_end = __STAB_END__;
  1003a8:	c7 45 ec cc b4 10 00 	movl   $0x10b4cc,-0x14(%ebp)
	stabstr = __STABSTR_BEGIN__;
  1003af:	c7 45 f0 cd b4 10 00 	movl   $0x10b4cd,-0x10(%ebp)
	stabstr_end = __STABSTR_END__;
  1003b6:	c7 45 f4 23 ce 10 00 	movl   $0x10ce23,-0xc(%ebp)

	// String table validity checks
	if (stabstr_end <= stabstr || stabstr_end[-1] != 0) {
  1003bd:	8b 45 f4             	mov    -0xc(%ebp),%eax
  1003c0:	3b 45 f0             	cmp    -0x10(%ebp),%eax
  1003c3:	76 0d                	jbe    1003d2 <debuginfo_eip+0x72>
  1003c5:	8b 45 f4             	mov    -0xc(%ebp),%eax
  1003c8:	83 e8 01             	sub    $0x1,%eax
  1003cb:	0f b6 00             	movzbl (%eax),%eax
  1003ce:	84 c0                	test   %al,%al
  1003d0:	74 0a                	je     1003dc <debuginfo_eip+0x7c>
		return -1;
  1003d2:	b8 ff ff ff ff       	mov    $0xffffffff,%eax
  1003d7:	e9 9e 02 00 00       	jmp    10067a <debuginfo_eip+0x31a>
	// 'eip'.  First, we find the basic source file containing 'eip'.
	// Then, we look in that source file for the function.  Then we look
	// for the line number.

	// Search the entire set of stabs for the source file (type N_SO).
	int lfile = 0, rfile = (stab_end - stabs) - 1;
  1003dc:	c7 45 e4 00 00 00 00 	movl   $0x0,-0x1c(%ebp)
  1003e3:	8b 55 ec             	mov    -0x14(%ebp),%edx
  1003e6:	8b 45 e8             	mov    -0x18(%ebp),%eax
  1003e9:	89 d1                	mov    %edx,%ecx
  1003eb:	29 c1                	sub    %eax,%ecx
  1003ed:	89 c8                	mov    %ecx,%eax
  1003ef:	c1 f8 02             	sar    $0x2,%eax
  1003f2:	69 c0 ab aa aa aa    	imul   $0xaaaaaaab,%eax,%eax
  1003f8:	83 e8 01             	sub    $0x1,%eax
  1003fb:	89 45 e0             	mov    %eax,-0x20(%ebp)
	stab_binsearch(stabs, &lfile, &rfile, N_SO, addr);
  1003fe:	8b 45 08             	mov    0x8(%ebp),%eax
  100401:	89 44 24 10          	mov    %eax,0x10(%esp)
  100405:	c7 44 24 0c 64 00 00 	movl   $0x64,0xc(%esp)
  10040c:	00 
  10040d:	8d 45 e0             	lea    -0x20(%ebp),%eax
  100410:	89 44 24 08          	mov    %eax,0x8(%esp)
  100414:	8d 45 e4             	lea    -0x1c(%ebp),%eax
  100417:	89 44 24 04          	mov    %eax,0x4(%esp)
  10041b:	8b 45 e8             	mov    -0x18(%ebp),%eax
  10041e:	89 04 24             	mov    %eax,(%esp)
  100421:	e8 f2 fd ff ff       	call   100218 <stab_binsearch>
	if (lfile == 0)
  100426:	8b 45 e4             	mov    -0x1c(%ebp),%eax
  100429:	85 c0                	test   %eax,%eax
  10042b:	75 0a                	jne    100437 <debuginfo_eip+0xd7>
		return -1;
  10042d:	b8 ff ff ff ff       	mov    $0xffffffff,%eax
  100432:	e9 43 02 00 00       	jmp    10067a <debuginfo_eip+0x31a>

	// Search within that file's stabs for the function definition
	// (N_FUN).
	int lfun = lfile, rfun = rfile;
  100437:	8b 45 e4             	mov    -0x1c(%ebp),%eax
  10043a:	89 45 dc             	mov    %eax,-0x24(%ebp)
  10043d:	8b 45 e0             	mov    -0x20(%ebp),%eax
  100440:	89 45 d8             	mov    %eax,-0x28(%ebp)
	int lline, rline;
	stab_binsearch(stabs, &lfun, &rfun, N_FUN, addr);
  100443:	8b 45 08             	mov    0x8(%ebp),%eax
  100446:	89 44 24 10          	mov    %eax,0x10(%esp)
  10044a:	c7 44 24 0c 24 00 00 	movl   $0x24,0xc(%esp)
  100451:	00 
  100452:	8d 45 d8             	lea    -0x28(%ebp),%eax
  100455:	89 44 24 08          	mov    %eax,0x8(%esp)
  100459:	8d 45 dc             	lea    -0x24(%ebp),%eax
  10045c:	89 44 24 04          	mov    %eax,0x4(%esp)
  100460:	8b 45 e8             	mov    -0x18(%ebp),%eax
  100463:	89 04 24             	mov    %eax,(%esp)
  100466:	e8 ad fd ff ff       	call   100218 <stab_binsearch>

	if (lfun <= rfun) {
  10046b:	8b 55 dc             	mov    -0x24(%ebp),%edx
  10046e:	8b 45 d8             	mov    -0x28(%ebp),%eax
  100471:	39 c2                	cmp    %eax,%edx
  100473:	7f 72                	jg     1004e7 <debuginfo_eip+0x187>
		// stabs[lfun] points to the function name
		// in the string table, but check bounds just in case.
		if (stabs[lfun].n_strx < stabstr_end - stabstr) {
  100475:	8b 45 dc             	mov    -0x24(%ebp),%eax
  100478:	89 c2                	mov    %eax,%edx
  10047a:	89 d0                	mov    %edx,%eax
  10047c:	01 c0                	add    %eax,%eax
  10047e:	01 d0                	add    %edx,%eax
  100480:	c1 e0 02             	shl    $0x2,%eax
  100483:	03 45 e8             	add    -0x18(%ebp),%eax
  100486:	8b 10                	mov    (%eax),%edx
  100488:	8b 4d f4             	mov    -0xc(%ebp),%ecx
  10048b:	8b 45 f0             	mov    -0x10(%ebp),%eax
  10048e:	89 cb                	mov    %ecx,%ebx
  100490:	29 c3                	sub    %eax,%ebx
  100492:	89 d8                	mov    %ebx,%eax
  100494:	39 c2                	cmp    %eax,%edx
  100496:	73 1e                	jae    1004b6 <debuginfo_eip+0x156>
			info->eip_fn_name = stabstr + stabs[lfun].n_strx;
  100498:	8b 45 dc             	mov    -0x24(%ebp),%eax
  10049b:	89 c2                	mov    %eax,%edx
  10049d:	89 d0                	mov    %edx,%eax
  10049f:	01 c0                	add    %eax,%eax
  1004a1:	01 d0                	add    %edx,%eax
  1004a3:	c1 e0 02             	shl    $0x2,%eax
  1004a6:	03 45 e8             	add    -0x18(%ebp),%eax
  1004a9:	8b 00                	mov    (%eax),%eax
  1004ab:	89 c2                	mov    %eax,%edx
  1004ad:	03 55 f0             	add    -0x10(%ebp),%edx
  1004b0:	8b 45 0c             	mov    0xc(%ebp),%eax
  1004b3:	89 50 08             	mov    %edx,0x8(%eax)
		}
		info->eip_fn_addr = stabs[lfun].n_value;
  1004b6:	8b 45 dc             	mov    -0x24(%ebp),%eax
  1004b9:	89 c2                	mov    %eax,%edx
  1004bb:	89 d0                	mov    %edx,%eax
  1004bd:	01 c0                	add    %eax,%eax
  1004bf:	01 d0                	add    %edx,%eax
  1004c1:	c1 e0 02             	shl    $0x2,%eax
  1004c4:	03 45 e8             	add    -0x18(%ebp),%eax
  1004c7:	8b 50 08             	mov    0x8(%eax),%edx
  1004ca:	8b 45 0c             	mov    0xc(%ebp),%eax
  1004cd:	89 50 10             	mov    %edx,0x10(%eax)
		addr -= info->eip_fn_addr;
  1004d0:	8b 45 0c             	mov    0xc(%ebp),%eax
  1004d3:	8b 40 10             	mov    0x10(%eax),%eax
  1004d6:	29 45 08             	sub    %eax,0x8(%ebp)
		// Search within the function definition for the line number.
		lline = lfun;
  1004d9:	8b 45 dc             	mov    -0x24(%ebp),%eax
  1004dc:	89 45 d4             	mov    %eax,-0x2c(%ebp)
		rline = rfun;
  1004df:	8b 45 d8             	mov    -0x28(%ebp),%eax
  1004e2:	89 45 d0             	mov    %eax,-0x30(%ebp)
  1004e5:	eb 15                	jmp    1004fc <debuginfo_eip+0x19c>
	} else {
		// Couldn't find function stab!  Maybe we're in an assembly
		// file.  Search the whole file for the line number.
		info->eip_fn_addr = addr;
  1004e7:	8b 45 0c             	mov    0xc(%ebp),%eax
  1004ea:	8b 55 08             	mov    0x8(%ebp),%edx
  1004ed:	89 50 10             	mov    %edx,0x10(%eax)
		lline = lfile;
  1004f0:	8b 45 e4             	mov    -0x1c(%ebp),%eax
  1004f3:	89 45 d4             	mov    %eax,-0x2c(%ebp)
		rline = rfile;
  1004f6:	8b 45 e0             	mov    -0x20(%ebp),%eax
  1004f9:	89 45 d0             	mov    %eax,-0x30(%ebp)
	}
	info->eip_fn_namelen = strfind(info->eip_fn_name, ':') - info->eip_fn_name;
  1004fc:	8b 45 0c             	mov    0xc(%ebp),%eax
  1004ff:	8b 40 08             	mov    0x8(%eax),%eax
  100502:	c7 44 24 04 3a 00 00 	movl   $0x3a,0x4(%esp)
  100509:	00 
  10050a:	89 04 24             	mov    %eax,(%esp)
  10050d:	e8 91 28 00 00       	call   102da3 <strfind>
  100512:	89 c2                	mov    %eax,%edx
  100514:	8b 45 0c             	mov    0xc(%ebp),%eax
  100517:	8b 40 08             	mov    0x8(%eax),%eax
  10051a:	29 c2                	sub    %eax,%edx
  10051c:	8b 45 0c             	mov    0xc(%ebp),%eax
  10051f:	89 50 0c             	mov    %edx,0xc(%eax)

	// Search within [lline, rline] for the line number stab.
	// If found, set info->eip_line to the right line number.
	// If not found, return -1.
	stab_binsearch(stabs, &lline, &rline, N_SLINE, addr);
  100522:	8b 45 08             	mov    0x8(%ebp),%eax
  100525:	89 44 24 10          	mov    %eax,0x10(%esp)
  100529:	c7 44 24 0c 44 00 00 	movl   $0x44,0xc(%esp)
  100530:	00 
  100531:	8d 45 d0             	lea    -0x30(%ebp),%eax
  100534:	89 44 24 08          	mov    %eax,0x8(%esp)
  100538:	8d 45 d4             	lea    -0x2c(%ebp),%eax
  10053b:	89 44 24 04          	mov    %eax,0x4(%esp)
  10053f:	8b 45 e8             	mov    -0x18(%ebp),%eax
  100542:	89 04 24             	mov    %eax,(%esp)
  100545:	e8 ce fc ff ff       	call   100218 <stab_binsearch>
	if (lline <= rline) {
  10054a:	8b 55 d4             	mov    -0x2c(%ebp),%edx
  10054d:	8b 45 d0             	mov    -0x30(%ebp),%eax
  100550:	39 c2                	cmp    %eax,%edx
  100552:	7f 20                	jg     100574 <debuginfo_eip+0x214>
		info->eip_line = stabs[rline].n_desc;
  100554:	8b 45 d0             	mov    -0x30(%ebp),%eax
  100557:	89 c2                	mov    %eax,%edx
  100559:	89 d0                	mov    %edx,%eax
  10055b:	01 c0                	add    %eax,%eax
  10055d:	01 d0                	add    %edx,%eax
  10055f:	c1 e0 02             	shl    $0x2,%eax
  100562:	03 45 e8             	add    -0x18(%ebp),%eax
  100565:	0f b7 40 06          	movzwl 0x6(%eax),%eax
  100569:	0f b7 d0             	movzwl %ax,%edx
  10056c:	8b 45 0c             	mov    0xc(%ebp),%eax
  10056f:	89 50 04             	mov    %edx,0x4(%eax)

	// Search backwards from the line number for the relevant filename stab.
	// We can't just use the "lfile" stab because inlined functions
	// can interpolate code from a different file!
	// Such included source files use the N_SOL stab type.
	while (lline >= lfile
  100572:	eb 13                	jmp    100587 <debuginfo_eip+0x227>
	// If not found, return -1.
	stab_binsearch(stabs, &lline, &rline, N_SLINE, addr);
	if (lline <= rline) {
		info->eip_line = stabs[rline].n_desc;
	} else {
		return -1;
  100574:	b8 ff ff ff ff       	mov    $0xffffffff,%eax
  100579:	e9 fc 00 00 00       	jmp    10067a <debuginfo_eip+0x31a>
	// can interpolate code from a different file!
	// Such included source files use the N_SOL stab type.
	while (lline >= lfile
	       && stabs[lline].n_type != N_SOL
	       && (stabs[lline].n_type != N_SO || !stabs[lline].n_value)) {
		lline --;
  10057e:	8b 45 d4             	mov    -0x2c(%ebp),%eax
  100581:	83 e8 01             	sub    $0x1,%eax
  100584:	89 45 d4             	mov    %eax,-0x2c(%ebp)
	// Search backwards from the line number for the relevant filename stab.
	// We can't just use the "lfile" stab because inlined functions
	// can interpolate code from a different file!
	// Such included source files use the N_SOL stab type.
	while (lline >= lfile
	       && stabs[lline].n_type != N_SOL
  100587:	8b 55 d4             	mov    -0x2c(%ebp),%edx
  10058a:	8b 45 e4             	mov    -0x1c(%ebp),%eax

	// Search backwards from the line number for the relevant filename stab.
	// We can't just use the "lfile" stab because inlined functions
	// can interpolate code from a different file!
	// Such included source files use the N_SOL stab type.
	while (lline >= lfile
  10058d:	39 c2                	cmp    %eax,%edx
  10058f:	7c 4a                	jl     1005db <debuginfo_eip+0x27b>
	       && stabs[lline].n_type != N_SOL
  100591:	8b 45 d4             	mov    -0x2c(%ebp),%eax
  100594:	89 c2                	mov    %eax,%edx
  100596:	89 d0                	mov    %edx,%eax
  100598:	01 c0                	add    %eax,%eax
  10059a:	01 d0                	add    %edx,%eax
  10059c:	c1 e0 02             	shl    $0x2,%eax
  10059f:	03 45 e8             	add    -0x18(%ebp),%eax
	       && (stabs[lline].n_type != N_SO || !stabs[lline].n_value)) {
  1005a2:	0f b6 40 04          	movzbl 0x4(%eax),%eax

	// Search backwards from the line number for the relevant filename stab.
	// We can't just use the "lfile" stab because inlined functions
	// can interpolate code from a different file!
	// Such included source files use the N_SOL stab type.
	while (lline >= lfile
  1005a6:	3c 84                	cmp    $0x84,%al
  1005a8:	74 31                	je     1005db <debuginfo_eip+0x27b>
	       && stabs[lline].n_type != N_SOL
	       && (stabs[lline].n_type != N_SO || !stabs[lline].n_value)) {
  1005aa:	8b 45 d4             	mov    -0x2c(%ebp),%eax
  1005ad:	89 c2                	mov    %eax,%edx
  1005af:	89 d0                	mov    %edx,%eax
  1005b1:	01 c0                	add    %eax,%eax
  1005b3:	01 d0                	add    %edx,%eax
  1005b5:	c1 e0 02             	shl    $0x2,%eax
  1005b8:	03 45 e8             	add    -0x18(%ebp),%eax
  1005bb:	0f b6 40 04          	movzbl 0x4(%eax),%eax

	// Search backwards from the line number for the relevant filename stab.
	// We can't just use the "lfile" stab because inlined functions
	// can interpolate code from a different file!
	// Such included source files use the N_SOL stab type.
	while (lline >= lfile
  1005bf:	3c 64                	cmp    $0x64,%al
  1005c1:	75 bb                	jne    10057e <debuginfo_eip+0x21e>
	       && stabs[lline].n_type != N_SOL
	       && (stabs[lline].n_type != N_SO || !stabs[lline].n_value)) {
  1005c3:	8b 45 d4             	mov    -0x2c(%ebp),%eax
  1005c6:	89 c2                	mov    %eax,%edx
  1005c8:	89 d0                	mov    %edx,%eax
  1005ca:	01 c0                	add    %eax,%eax
  1005cc:	01 d0                	add    %edx,%eax
  1005ce:	c1 e0 02             	shl    $0x2,%eax
  1005d1:	03 45 e8             	add    -0x18(%ebp),%eax
  1005d4:	8b 40 08             	mov    0x8(%eax),%eax

	// Search backwards from the line number for the relevant filename stab.
	// We can't just use the "lfile" stab because inlined functions
	// can interpolate code from a different file!
	// Such included source files use the N_SOL stab type.
	while (lline >= lfile
  1005d7:	85 c0                	test   %eax,%eax
  1005d9:	74 a3                	je     10057e <debuginfo_eip+0x21e>
	       && stabs[lline].n_type != N_SOL
	       && (stabs[lline].n_type != N_SO || !stabs[lline].n_value)) {
		lline --;
	}
	if (lline >= lfile && stabs[lline].n_strx < stabstr_end - stabstr) {
  1005db:	8b 55 d4             	mov    -0x2c(%ebp),%edx
  1005de:	8b 45 e4             	mov    -0x1c(%ebp),%eax
  1005e1:	39 c2                	cmp    %eax,%edx
  1005e3:	7c 40                	jl     100625 <debuginfo_eip+0x2c5>
  1005e5:	8b 45 d4             	mov    -0x2c(%ebp),%eax
  1005e8:	89 c2                	mov    %eax,%edx
  1005ea:	89 d0                	mov    %edx,%eax
  1005ec:	01 c0                	add    %eax,%eax
  1005ee:	01 d0                	add    %edx,%eax
  1005f0:	c1 e0 02             	shl    $0x2,%eax
  1005f3:	03 45 e8             	add    -0x18(%ebp),%eax
  1005f6:	8b 10                	mov    (%eax),%edx
  1005f8:	8b 4d f4             	mov    -0xc(%ebp),%ecx
  1005fb:	8b 45 f0             	mov    -0x10(%ebp),%eax
  1005fe:	89 cb                	mov    %ecx,%ebx
  100600:	29 c3                	sub    %eax,%ebx
  100602:	89 d8                	mov    %ebx,%eax
  100604:	39 c2                	cmp    %eax,%edx
  100606:	73 1d                	jae    100625 <debuginfo_eip+0x2c5>
		info->eip_file = stabstr + stabs[lline].n_strx;
  100608:	8b 45 d4             	mov    -0x2c(%ebp),%eax
  10060b:	89 c2                	mov    %eax,%edx
  10060d:	89 d0                	mov    %edx,%eax
  10060f:	01 c0                	add    %eax,%eax
  100611:	01 d0                	add    %edx,%eax
  100613:	c1 e0 02             	shl    $0x2,%eax
  100616:	03 45 e8             	add    -0x18(%ebp),%eax
  100619:	8b 00                	mov    (%eax),%eax
  10061b:	89 c2                	mov    %eax,%edx
  10061d:	03 55 f0             	add    -0x10(%ebp),%edx
  100620:	8b 45 0c             	mov    0xc(%ebp),%eax
  100623:	89 10                	mov    %edx,(%eax)
	}

	// Set eip_fn_narg to the number of arguments taken by the function,
	// or 0 if there was no containing function.
	if (lfun < rfun) {
  100625:	8b 55 dc             	mov    -0x24(%ebp),%edx
  100628:	8b 45 d8             	mov    -0x28(%ebp),%eax
  10062b:	39 c2                	cmp    %eax,%edx
  10062d:	7d 46                	jge    100675 <debuginfo_eip+0x315>
		for (lline = lfun + 1;
  10062f:	8b 45 dc             	mov    -0x24(%ebp),%eax
  100632:	83 c0 01             	add    $0x1,%eax
  100635:	89 45 d4             	mov    %eax,-0x2c(%ebp)
  100638:	eb 18                	jmp    100652 <debuginfo_eip+0x2f2>
		     lline < rfun && stabs[lline].n_type == N_PSYM;
		     lline ++) {
			info->eip_fn_narg ++;
  10063a:	8b 45 0c             	mov    0xc(%ebp),%eax
  10063d:	8b 40 14             	mov    0x14(%eax),%eax
  100640:	8d 50 01             	lea    0x1(%eax),%edx
  100643:	8b 45 0c             	mov    0xc(%ebp),%eax
  100646:	89 50 14             	mov    %edx,0x14(%eax)
	// Set eip_fn_narg to the number of arguments taken by the function,
	// or 0 if there was no containing function.
	if (lfun < rfun) {
		for (lline = lfun + 1;
		     lline < rfun && stabs[lline].n_type == N_PSYM;
		     lline ++) {
  100649:	8b 45 d4             	mov    -0x2c(%ebp),%eax
  10064c:	83 c0 01             	add    $0x1,%eax
  10064f:	89 45 d4             	mov    %eax,-0x2c(%ebp)

	// Set eip_fn_narg to the number of arguments taken by the function,
	// or 0 if there was no containing function.
	if (lfun < rfun) {
		for (lline = lfun + 1;
		     lline < rfun && stabs[lline].n_type == N_PSYM;
  100652:	8b 55 d4             	mov    -0x2c(%ebp),%edx
  100655:	8b 45 d8             	mov    -0x28(%ebp),%eax
	}

	// Set eip_fn_narg to the number of arguments taken by the function,
	// or 0 if there was no containing function.
	if (lfun < rfun) {
		for (lline = lfun + 1;
  100658:	39 c2                	cmp    %eax,%edx
  10065a:	7d 19                	jge    100675 <debuginfo_eip+0x315>
		     lline < rfun && stabs[lline].n_type == N_PSYM;
  10065c:	8b 45 d4             	mov    -0x2c(%ebp),%eax
  10065f:	89 c2                	mov    %eax,%edx
  100661:	89 d0                	mov    %edx,%eax
  100663:	01 c0                	add    %eax,%eax
  100665:	01 d0                	add    %edx,%eax
  100667:	c1 e0 02             	shl    $0x2,%eax
  10066a:	03 45 e8             	add    -0x18(%ebp),%eax
  10066d:	0f b6 40 04          	movzbl 0x4(%eax),%eax
	}

	// Set eip_fn_narg to the number of arguments taken by the function,
	// or 0 if there was no containing function.
	if (lfun < rfun) {
		for (lline = lfun + 1;
  100671:	3c a0                	cmp    $0xa0,%al
  100673:	74 c5                	je     10063a <debuginfo_eip+0x2da>
		     lline < rfun && stabs[lline].n_type == N_PSYM;
		     lline ++) {
			info->eip_fn_narg ++;
		}
	}
	return 0;
  100675:	b8 00 00 00 00       	mov    $0x0,%eax
}
  10067a:	83 c4 54             	add    $0x54,%esp
  10067d:	5b                   	pop    %ebx
  10067e:	5d                   	pop    %ebp
  10067f:	c3                   	ret    

00100680 <print_kerninfo>:
 * print_kerninfo - print the information about kernel, including the location
 * of kernel entry, the start addresses of data and text segements, the start
 * address of free memory and how many memory that kernel has used.
 * */
void
print_kerninfo(void) {
  100680:	55                   	push   %ebp
  100681:	89 e5                	mov    %esp,%ebp
  100683:	83 ec 18             	sub    $0x18,%esp
	extern char etext[], edata[], end[], kern_init[];
	cprintf("Special kernel symbols:\n");
  100686:	c7 04 24 ee 30 10 00 	movl   $0x1030ee,(%esp)
  10068d:	e8 de fa ff ff       	call   100170 <cprintf>
	cprintf("  entry  0x%08x (phys)\n", kern_init);
  100692:	c7 44 24 04 00 00 10 	movl   $0x100000,0x4(%esp)
  100699:	00 
  10069a:	c7 04 24 07 31 10 00 	movl   $0x103107,(%esp)
  1006a1:	e8 ca fa ff ff       	call   100170 <cprintf>
	cprintf("  etext  0x%08x (phys)\n", etext);
  1006a6:	c7 44 24 04 af 30 10 	movl   $0x1030af,0x4(%esp)
  1006ad:	00 
  1006ae:	c7 04 24 1f 31 10 00 	movl   $0x10311f,(%esp)
  1006b5:	e8 b6 fa ff ff       	call   100170 <cprintf>
	cprintf("  edata  0x%08x (phys)\n", edata);
  1006ba:	c7 44 24 04 e0 d9 10 	movl   $0x10d9e0,0x4(%esp)
  1006c1:	00 
  1006c2:	c7 04 24 37 31 10 00 	movl   $0x103137,(%esp)
  1006c9:	e8 a2 fa ff ff       	call   100170 <cprintf>
	cprintf("  end    0x%08x (phys)\n", end);
  1006ce:	c7 44 24 04 64 e8 10 	movl   $0x10e864,0x4(%esp)
  1006d5:	00 
  1006d6:	c7 04 24 4f 31 10 00 	movl   $0x10314f,(%esp)
  1006dd:	e8 8e fa ff ff       	call   100170 <cprintf>
	cprintf("Kernel executable memory footprint: %dKB\n", (end - kern_init + 1023)/1024);
  1006e2:	b8 64 e8 10 00       	mov    $0x10e864,%eax
  1006e7:	8d 90 ff 03 00 00    	lea    0x3ff(%eax),%edx
  1006ed:	b8 00 00 10 00       	mov    $0x100000,%eax
  1006f2:	89 d1                	mov    %edx,%ecx
  1006f4:	29 c1                	sub    %eax,%ecx
  1006f6:	89 c8                	mov    %ecx,%eax
  1006f8:	8d 90 ff 03 00 00    	lea    0x3ff(%eax),%edx
  1006fe:	85 c0                	test   %eax,%eax
  100700:	0f 48 c2             	cmovs  %edx,%eax
  100703:	c1 f8 0a             	sar    $0xa,%eax
  100706:	89 44 24 04          	mov    %eax,0x4(%esp)
  10070a:	c7 04 24 68 31 10 00 	movl   $0x103168,(%esp)
  100711:	e8 5a fa ff ff       	call   100170 <cprintf>
}
  100716:	c9                   	leave  
  100717:	c3                   	ret    

00100718 <print_debuginfo>:
/* *
 * print_debuginfo - read and print the stat information for the address @eip,
 * and info.eip_fn_addr should be the first address of the related function.
 * */
void
print_debuginfo(uintptr_t eip) {
  100718:	55                   	push   %ebp
  100719:	89 e5                	mov    %esp,%ebp
  10071b:	81 ec 48 01 00 00    	sub    $0x148,%esp
	struct eipdebuginfo info;
	if (debuginfo_eip(eip, &info) != 0) {
  100721:	8d 45 dc             	lea    -0x24(%ebp),%eax
  100724:	89 44 24 04          	mov    %eax,0x4(%esp)
  100728:	8b 45 08             	mov    0x8(%ebp),%eax
  10072b:	89 04 24             	mov    %eax,(%esp)
  10072e:	e8 2d fc ff ff       	call   100360 <debuginfo_eip>
  100733:	85 c0                	test   %eax,%eax
  100735:	74 15                	je     10074c <print_debuginfo+0x34>
		cprintf("    <unknow>: -- 0x%08x --\n", eip);
  100737:	8b 45 08             	mov    0x8(%ebp),%eax
  10073a:	89 44 24 04          	mov    %eax,0x4(%esp)
  10073e:	c7 04 24 92 31 10 00 	movl   $0x103192,(%esp)
  100745:	e8 26 fa ff ff       	call   100170 <cprintf>
  10074a:	eb 68                	jmp    1007b4 <print_debuginfo+0x9c>
	}
	else {
		char fnname[256];
		int j;
		for (j = 0; j < info.eip_fn_namelen; j ++) {
  10074c:	c7 45 f4 00 00 00 00 	movl   $0x0,-0xc(%ebp)
  100753:	eb 1a                	jmp    10076f <print_debuginfo+0x57>
			fnname[j] = info.eip_fn_name[j];
  100755:	8b 45 f4             	mov    -0xc(%ebp),%eax
  100758:	8b 4d e4             	mov    -0x1c(%ebp),%ecx
  10075b:	8b 55 f4             	mov    -0xc(%ebp),%edx
  10075e:	8d 14 11             	lea    (%ecx,%edx,1),%edx
  100761:	0f b6 12             	movzbl (%edx),%edx
  100764:	88 94 05 dc fe ff ff 	mov    %dl,-0x124(%ebp,%eax,1)
		cprintf("    <unknow>: -- 0x%08x --\n", eip);
	}
	else {
		char fnname[256];
		int j;
		for (j = 0; j < info.eip_fn_namelen; j ++) {
  10076b:	83 45 f4 01          	addl   $0x1,-0xc(%ebp)
  10076f:	8b 45 e8             	mov    -0x18(%ebp),%eax
  100772:	3b 45 f4             	cmp    -0xc(%ebp),%eax
  100775:	7f de                	jg     100755 <print_debuginfo+0x3d>
			fnname[j] = info.eip_fn_name[j];
		}
		fnname[j] = '\0';
  100777:	8b 45 f4             	mov    -0xc(%ebp),%eax
  10077a:	c6 84 05 dc fe ff ff 	movb   $0x0,-0x124(%ebp,%eax,1)
  100781:	00 
		cprintf("    %s:%d: %s+%d\n", info.eip_file, info.eip_line,
  100782:	8b 45 ec             	mov    -0x14(%ebp),%eax
  100785:	8b 55 08             	mov    0x8(%ebp),%edx
  100788:	89 d1                	mov    %edx,%ecx
  10078a:	29 c1                	sub    %eax,%ecx
  10078c:	8b 55 e0             	mov    -0x20(%ebp),%edx
  10078f:	8b 45 dc             	mov    -0x24(%ebp),%eax
  100792:	89 4c 24 10          	mov    %ecx,0x10(%esp)
  100796:	8d 8d dc fe ff ff    	lea    -0x124(%ebp),%ecx
  10079c:	89 4c 24 0c          	mov    %ecx,0xc(%esp)
  1007a0:	89 54 24 08          	mov    %edx,0x8(%esp)
  1007a4:	89 44 24 04          	mov    %eax,0x4(%esp)
  1007a8:	c7 04 24 ae 31 10 00 	movl   $0x1031ae,(%esp)
  1007af:	e8 bc f9 ff ff       	call   100170 <cprintf>
				fnname, eip - info.eip_fn_addr);
	}
}
  1007b4:	c9                   	leave  
  1007b5:	c3                   	ret    

001007b6 <read_eip>:

static uint32_t read_eip(void) __attribute__((noinline));

static uint32_t
read_eip(void) {
  1007b6:	55                   	push   %ebp
  1007b7:	89 e5                	mov    %esp,%ebp
  1007b9:	83 ec 10             	sub    $0x10,%esp
	uint32_t eip;
	asm volatile("movl 4(%%ebp), %0" : "=r" (eip));
  1007bc:	8b 45 04             	mov    0x4(%ebp),%eax
  1007bf:	89 45 fc             	mov    %eax,-0x4(%ebp)
	return eip;
  1007c2:	8b 45 fc             	mov    -0x4(%ebp),%eax
}
  1007c5:	c9                   	leave  
  1007c6:	c3                   	ret    

001007c7 <print_stackframe>:
 *
 * Note that, the length of ebp-chain is limited. In boot/bootasm.S, before jumping
 * to the kernel entry, the value of ebp has been set to zero, that's the boundary.
 * */
void
print_stackframe(void) {
  1007c7:	55                   	push   %ebp
  1007c8:	89 e5                	mov    %esp,%ebp
	 /* LAB1 YOUR CODE */
}
  1007ca:	5d                   	pop    %ebp
  1007cb:	c3                   	ret    

001007cc <parse>:
#define MAXARGS			16
#define WHITESPACE		" \t\n\r"

/* parse - parse the command buffer into whitespace-separated arguments */
static int
parse(char *buf, char **argv) {
  1007cc:	55                   	push   %ebp
  1007cd:	89 e5                	mov    %esp,%ebp
  1007cf:	83 ec 28             	sub    $0x28,%esp
	int argc = 0;
  1007d2:	c7 45 f4 00 00 00 00 	movl   $0x0,-0xc(%ebp)
	while (1) {
		// find global whitespace
		while (*buf != '\0' && strchr(WHITESPACE, *buf) != NULL) {
  1007d9:	eb 0a                	jmp    1007e5 <parse+0x19>
			*buf ++ = '\0';
  1007db:	8b 45 08             	mov    0x8(%ebp),%eax
  1007de:	c6 00 00             	movb   $0x0,(%eax)
  1007e1:	83 45 08 01          	addl   $0x1,0x8(%ebp)
static int
parse(char *buf, char **argv) {
	int argc = 0;
	while (1) {
		// find global whitespace
		while (*buf != '\0' && strchr(WHITESPACE, *buf) != NULL) {
  1007e5:	8b 45 08             	mov    0x8(%ebp),%eax
  1007e8:	0f b6 00             	movzbl (%eax),%eax
  1007eb:	84 c0                	test   %al,%al
  1007ed:	74 1d                	je     10080c <parse+0x40>
  1007ef:	8b 45 08             	mov    0x8(%ebp),%eax
  1007f2:	0f b6 00             	movzbl (%eax),%eax
  1007f5:	0f be c0             	movsbl %al,%eax
  1007f8:	89 44 24 04          	mov    %eax,0x4(%esp)
  1007fc:	c7 04 24 40 32 10 00 	movl   $0x103240,(%esp)
  100803:	e8 68 25 00 00       	call   102d70 <strchr>
  100808:	85 c0                	test   %eax,%eax
  10080a:	75 cf                	jne    1007db <parse+0xf>
			*buf ++ = '\0';
		}
		if (*buf == '\0') {
  10080c:	8b 45 08             	mov    0x8(%ebp),%eax
  10080f:	0f b6 00             	movzbl (%eax),%eax
  100812:	84 c0                	test   %al,%al
  100814:	75 05                	jne    10081b <parse+0x4f>
		argv[argc ++] = buf;
		while (*buf != '\0' && strchr(WHITESPACE, *buf) == NULL) {
			buf ++;
		}
	}
	return argc;
  100816:	8b 45 f4             	mov    -0xc(%ebp),%eax
}
  100819:	c9                   	leave  
  10081a:	c3                   	ret    
		if (*buf == '\0') {
			break;
		}

		// save and scan past next arg
		if (argc == MAXARGS - 1) {
  10081b:	83 7d f4 0f          	cmpl   $0xf,-0xc(%ebp)
  10081f:	75 14                	jne    100835 <parse+0x69>
			cprintf("Too many arguments (max %d).\n", MAXARGS);
  100821:	c7 44 24 04 10 00 00 	movl   $0x10,0x4(%esp)
  100828:	00 
  100829:	c7 04 24 45 32 10 00 	movl   $0x103245,(%esp)
  100830:	e8 3b f9 ff ff       	call   100170 <cprintf>
		}
		argv[argc ++] = buf;
  100835:	8b 45 f4             	mov    -0xc(%ebp),%eax
  100838:	c1 e0 02             	shl    $0x2,%eax
  10083b:	03 45 0c             	add    0xc(%ebp),%eax
  10083e:	8b 55 08             	mov    0x8(%ebp),%edx
  100841:	89 10                	mov    %edx,(%eax)
  100843:	83 45 f4 01          	addl   $0x1,-0xc(%ebp)
		while (*buf != '\0' && strchr(WHITESPACE, *buf) == NULL) {
  100847:	eb 04                	jmp    10084d <parse+0x81>
			buf ++;
  100849:	83 45 08 01          	addl   $0x1,0x8(%ebp)
		// save and scan past next arg
		if (argc == MAXARGS - 1) {
			cprintf("Too many arguments (max %d).\n", MAXARGS);
		}
		argv[argc ++] = buf;
		while (*buf != '\0' && strchr(WHITESPACE, *buf) == NULL) {
  10084d:	8b 45 08             	mov    0x8(%ebp),%eax
  100850:	0f b6 00             	movzbl (%eax),%eax
  100853:	84 c0                	test   %al,%al
  100855:	74 1d                	je     100874 <parse+0xa8>
  100857:	8b 45 08             	mov    0x8(%ebp),%eax
  10085a:	0f b6 00             	movzbl (%eax),%eax
  10085d:	0f be c0             	movsbl %al,%eax
  100860:	89 44 24 04          	mov    %eax,0x4(%esp)
  100864:	c7 04 24 40 32 10 00 	movl   $0x103240,(%esp)
  10086b:	e8 00 25 00 00       	call   102d70 <strchr>
  100870:	85 c0                	test   %eax,%eax
  100872:	74 d5                	je     100849 <parse+0x7d>
			buf ++;
		}
	}
  100874:	90                   	nop
static int
parse(char *buf, char **argv) {
	int argc = 0;
	while (1) {
		// find global whitespace
		while (*buf != '\0' && strchr(WHITESPACE, *buf) != NULL) {
  100875:	e9 6b ff ff ff       	jmp    1007e5 <parse+0x19>

0010087a <runcmd>:
/* *
 * runcmd - parse the input string, split it into separated arguments
 * and then lookup and invoke some related commands/
 * */
static int
runcmd(char *buf, struct trapframe *tf) {
  10087a:	55                   	push   %ebp
  10087b:	89 e5                	mov    %esp,%ebp
  10087d:	83 ec 68             	sub    $0x68,%esp
	char *argv[MAXARGS];
	int argc = parse(buf, argv);
  100880:	8d 45 b0             	lea    -0x50(%ebp),%eax
  100883:	89 44 24 04          	mov    %eax,0x4(%esp)
  100887:	8b 45 08             	mov    0x8(%ebp),%eax
  10088a:	89 04 24             	mov    %eax,(%esp)
  10088d:	e8 3a ff ff ff       	call   1007cc <parse>
  100892:	89 45 f0             	mov    %eax,-0x10(%ebp)
	if (argc == 0) {
  100895:	83 7d f0 00          	cmpl   $0x0,-0x10(%ebp)
  100899:	75 0a                	jne    1008a5 <runcmd+0x2b>
		return 0;
  10089b:	b8 00 00 00 00       	mov    $0x0,%eax
  1008a0:	e9 82 00 00 00       	jmp    100927 <runcmd+0xad>
	}
	int i;
	for (i = 0; i < NCOMMANDS; i ++) {
  1008a5:	c7 45 f4 00 00 00 00 	movl   $0x0,-0xc(%ebp)
  1008ac:	eb 59                	jmp    100907 <runcmd+0x8d>
		if (strcmp(commands[i].name, argv[0]) == 0) {
  1008ae:	8b 4d b0             	mov    -0x50(%ebp),%ecx
  1008b1:	8b 55 f4             	mov    -0xc(%ebp),%edx
  1008b4:	89 d0                	mov    %edx,%eax
  1008b6:	01 c0                	add    %eax,%eax
  1008b8:	01 d0                	add    %edx,%eax
  1008ba:	c1 e0 02             	shl    $0x2,%eax
  1008bd:	8b 80 00 d0 10 00    	mov    0x10d000(%eax),%eax
  1008c3:	89 4c 24 04          	mov    %ecx,0x4(%esp)
  1008c7:	89 04 24             	mov    %eax,(%esp)
  1008ca:	e8 00 24 00 00       	call   102ccf <strcmp>
  1008cf:	85 c0                	test   %eax,%eax
  1008d1:	75 30                	jne    100903 <runcmd+0x89>
			return commands[i].func(argc - 1, argv + 1, tf);
  1008d3:	8b 55 f4             	mov    -0xc(%ebp),%edx
  1008d6:	89 d0                	mov    %edx,%eax
  1008d8:	01 c0                	add    %eax,%eax
  1008da:	01 d0                	add    %edx,%eax
  1008dc:	c1 e0 02             	shl    $0x2,%eax
  1008df:	8b 90 08 d0 10 00    	mov    0x10d008(%eax),%edx
  1008e5:	8b 45 f0             	mov    -0x10(%ebp),%eax
  1008e8:	8d 48 ff             	lea    -0x1(%eax),%ecx
  1008eb:	8b 45 0c             	mov    0xc(%ebp),%eax
  1008ee:	89 44 24 08          	mov    %eax,0x8(%esp)
  1008f2:	8d 45 b0             	lea    -0x50(%ebp),%eax
  1008f5:	83 c0 04             	add    $0x4,%eax
  1008f8:	89 44 24 04          	mov    %eax,0x4(%esp)
  1008fc:	89 0c 24             	mov    %ecx,(%esp)
  1008ff:	ff d2                	call   *%edx
  100901:	eb 24                	jmp    100927 <runcmd+0xad>
	int argc = parse(buf, argv);
	if (argc == 0) {
		return 0;
	}
	int i;
	for (i = 0; i < NCOMMANDS; i ++) {
  100903:	83 45 f4 01          	addl   $0x1,-0xc(%ebp)
  100907:	8b 45 f4             	mov    -0xc(%ebp),%eax
  10090a:	83 f8 02             	cmp    $0x2,%eax
  10090d:	76 9f                	jbe    1008ae <runcmd+0x34>
		if (strcmp(commands[i].name, argv[0]) == 0) {
			return commands[i].func(argc - 1, argv + 1, tf);
		}
	}
	cprintf("Unknown command '%s'\n", argv[0]);
  10090f:	8b 45 b0             	mov    -0x50(%ebp),%eax
  100912:	89 44 24 04          	mov    %eax,0x4(%esp)
  100916:	c7 04 24 63 32 10 00 	movl   $0x103263,(%esp)
  10091d:	e8 4e f8 ff ff       	call   100170 <cprintf>
	return 0;
  100922:	b8 00 00 00 00       	mov    $0x0,%eax
}
  100927:	c9                   	leave  
  100928:	c3                   	ret    

00100929 <monitor>:

/***** Implementations of basic kernel monitor commands *****/

void
monitor(struct trapframe *tf) {
  100929:	55                   	push   %ebp
  10092a:	89 e5                	mov    %esp,%ebp
  10092c:	83 ec 28             	sub    $0x28,%esp
	cprintf("Welcome to the kernel debug monitor!!\n");
  10092f:	c7 04 24 7c 32 10 00 	movl   $0x10327c,(%esp)
  100936:	e8 35 f8 ff ff       	call   100170 <cprintf>
	cprintf("Type 'help' for a list of commands.\n");
  10093b:	c7 04 24 a4 32 10 00 	movl   $0x1032a4,(%esp)
  100942:	e8 29 f8 ff ff       	call   100170 <cprintf>

	if (tf != NULL) {
  100947:	83 7d 08 00          	cmpl   $0x0,0x8(%ebp)
  10094b:	74 11                	je     10095e <monitor+0x35>
		print_trapframe(tf);
  10094d:	8b 45 08             	mov    0x8(%ebp),%eax
  100950:	89 04 24             	mov    %eax,(%esp)
  100953:	e8 f4 0d 00 00       	call   10174c <print_trapframe>
  100958:	eb 04                	jmp    10095e <monitor+0x35>
		if ((buf = readline("K> ")) != NULL) {
			if (runcmd(buf, tf) < 0) {
				break;
			}
		}
	}
  10095a:	90                   	nop
  10095b:	eb 01                	jmp    10095e <monitor+0x35>
  10095d:	90                   	nop
		print_trapframe(tf);
	}

	char *buf;
	while (1) {
		if ((buf = readline("K> ")) != NULL) {
  10095e:	c7 04 24 c9 32 10 00 	movl   $0x1032c9,(%esp)
  100965:	e8 fa f6 ff ff       	call   100064 <readline>
  10096a:	89 45 f4             	mov    %eax,-0xc(%ebp)
  10096d:	83 7d f4 00          	cmpl   $0x0,-0xc(%ebp)
  100971:	74 e7                	je     10095a <monitor+0x31>
			if (runcmd(buf, tf) < 0) {
  100973:	8b 45 08             	mov    0x8(%ebp),%eax
  100976:	89 44 24 04          	mov    %eax,0x4(%esp)
  10097a:	8b 45 f4             	mov    -0xc(%ebp),%eax
  10097d:	89 04 24             	mov    %eax,(%esp)
  100980:	e8 f5 fe ff ff       	call   10087a <runcmd>
  100985:	85 c0                	test   %eax,%eax
  100987:	79 d4                	jns    10095d <monitor+0x34>
				break;
			}
		}
	}
}
  100989:	90                   	nop
  10098a:	c9                   	leave  
  10098b:	c3                   	ret    

0010098c <mon_help>:

/* mon_help - print the information about mon_* functions */
int
mon_help(int argc, char **argv, struct trapframe *tf) {
  10098c:	55                   	push   %ebp
  10098d:	89 e5                	mov    %esp,%ebp
  10098f:	83 ec 28             	sub    $0x28,%esp
	int i;
	for (i = 0; i < NCOMMANDS; i ++) {
  100992:	c7 45 f4 00 00 00 00 	movl   $0x0,-0xc(%ebp)
  100999:	eb 3c                	jmp    1009d7 <mon_help+0x4b>
		cprintf("%s - %s\n", commands[i].name, commands[i].desc);
  10099b:	8b 55 f4             	mov    -0xc(%ebp),%edx
  10099e:	89 d0                	mov    %edx,%eax
  1009a0:	01 c0                	add    %eax,%eax
  1009a2:	01 d0                	add    %edx,%eax
  1009a4:	c1 e0 02             	shl    $0x2,%eax
  1009a7:	8b 88 04 d0 10 00    	mov    0x10d004(%eax),%ecx
  1009ad:	8b 55 f4             	mov    -0xc(%ebp),%edx
  1009b0:	89 d0                	mov    %edx,%eax
  1009b2:	01 c0                	add    %eax,%eax
  1009b4:	01 d0                	add    %edx,%eax
  1009b6:	c1 e0 02             	shl    $0x2,%eax
  1009b9:	8b 80 00 d0 10 00    	mov    0x10d000(%eax),%eax
  1009bf:	89 4c 24 08          	mov    %ecx,0x8(%esp)
  1009c3:	89 44 24 04          	mov    %eax,0x4(%esp)
  1009c7:	c7 04 24 cd 32 10 00 	movl   $0x1032cd,(%esp)
  1009ce:	e8 9d f7 ff ff       	call   100170 <cprintf>

/* mon_help - print the information about mon_* functions */
int
mon_help(int argc, char **argv, struct trapframe *tf) {
	int i;
	for (i = 0; i < NCOMMANDS; i ++) {
  1009d3:	83 45 f4 01          	addl   $0x1,-0xc(%ebp)
  1009d7:	8b 45 f4             	mov    -0xc(%ebp),%eax
  1009da:	83 f8 02             	cmp    $0x2,%eax
  1009dd:	76 bc                	jbe    10099b <mon_help+0xf>
		cprintf("%s - %s\n", commands[i].name, commands[i].desc);
	}
	return 0;
  1009df:	b8 00 00 00 00       	mov    $0x0,%eax
}
  1009e4:	c9                   	leave  
  1009e5:	c3                   	ret    

001009e6 <mon_kerninfo>:
/* *
 * mon_kerninfo - call print_kerninfo in kern/debug/kdebug.c to
 * print the memory occupancy in kernel.
 * */
int
mon_kerninfo(int argc, char **argv, struct trapframe *tf) {
  1009e6:	55                   	push   %ebp
  1009e7:	89 e5                	mov    %esp,%ebp
  1009e9:	83 ec 08             	sub    $0x8,%esp
	print_kerninfo();
  1009ec:	e8 8f fc ff ff       	call   100680 <print_kerninfo>
	return 0;
  1009f1:	b8 00 00 00 00       	mov    $0x0,%eax
}
  1009f6:	c9                   	leave  
  1009f7:	c3                   	ret    

001009f8 <mon_backtrace>:
/* *
 * mon_backtrace - call print_stackframe in kern/debug/kdebug.c to
 * print a backtrace of the stack.
 * */
int
mon_backtrace(int argc, char **argv, struct trapframe *tf) {
  1009f8:	55                   	push   %ebp
  1009f9:	89 e5                	mov    %esp,%ebp
  1009fb:	83 ec 08             	sub    $0x8,%esp
	print_stackframe();
  1009fe:	e8 c4 fd ff ff       	call   1007c7 <print_stackframe>
	return 0;
  100a03:	b8 00 00 00 00       	mov    $0x0,%eax
}
  100a08:	c9                   	leave  
  100a09:	c3                   	ret    
	...

00100a0c <__panic>:
/* *
 * __panic - __panic is called on unresolvable fatal errors. it prints
 * "panic: 'message'", and then enters the kernel monitor.
 * */
void
__panic(const char *file, int line, const char *fmt, ...) {
  100a0c:	55                   	push   %ebp
  100a0d:	89 e5                	mov    %esp,%ebp
  100a0f:	83 ec 28             	sub    $0x28,%esp
	if (is_panic) {
  100a12:	a1 e0 dd 10 00       	mov    0x10dde0,%eax
  100a17:	85 c0                	test   %eax,%eax
  100a19:	75 4d                	jne    100a68 <__panic+0x5c>
		goto panic_dead;
	}
	is_panic = 1;
  100a1b:	c7 05 e0 dd 10 00 01 	movl   $0x1,0x10dde0
  100a22:	00 00 00 

	// print the 'message'
	va_list ap;
	va_start(ap, fmt);
  100a25:	8d 45 10             	lea    0x10(%ebp),%eax
  100a28:	83 c0 04             	add    $0x4,%eax
  100a2b:	89 45 f4             	mov    %eax,-0xc(%ebp)
	cprintf("kernel panic at %s:%d:\n    ", file, line);
  100a2e:	8b 45 0c             	mov    0xc(%ebp),%eax
  100a31:	89 44 24 08          	mov    %eax,0x8(%esp)
  100a35:	8b 45 08             	mov    0x8(%ebp),%eax
  100a38:	89 44 24 04          	mov    %eax,0x4(%esp)
  100a3c:	c7 04 24 d6 32 10 00 	movl   $0x1032d6,(%esp)
  100a43:	e8 28 f7 ff ff       	call   100170 <cprintf>
	vcprintf(fmt, ap);
  100a48:	8b 45 10             	mov    0x10(%ebp),%eax
  100a4b:	8b 55 f4             	mov    -0xc(%ebp),%edx
  100a4e:	89 54 24 04          	mov    %edx,0x4(%esp)
  100a52:	89 04 24             	mov    %eax,(%esp)
  100a55:	e8 e2 f6 ff ff       	call   10013c <vcprintf>
	cprintf("\n");
  100a5a:	c7 04 24 f2 32 10 00 	movl   $0x1032f2,(%esp)
  100a61:	e8 0a f7 ff ff       	call   100170 <cprintf>
  100a66:	eb 01                	jmp    100a69 <__panic+0x5d>
 * "panic: 'message'", and then enters the kernel monitor.
 * */
void
__panic(const char *file, int line, const char *fmt, ...) {
	if (is_panic) {
		goto panic_dead;
  100a68:	90                   	nop
}

static inline void
cli(void) {
	asm volatile ("cli");
  100a69:	fa                   	cli    
	va_end(ap);

panic_dead:
	cli();
	while (1) {
		monitor(NULL);
  100a6a:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
  100a71:	e8 b3 fe ff ff       	call   100929 <monitor>
	}
  100a76:	eb f2                	jmp    100a6a <__panic+0x5e>

00100a78 <__warn>:
}

/* __warn - like panic, but don't */
void
__warn(const char *file, int line, const char *fmt, ...) {
  100a78:	55                   	push   %ebp
  100a79:	89 e5                	mov    %esp,%ebp
  100a7b:	83 ec 28             	sub    $0x28,%esp
	va_list ap;
	va_start(ap, fmt);
  100a7e:	8d 45 10             	lea    0x10(%ebp),%eax
  100a81:	83 c0 04             	add    $0x4,%eax
  100a84:	89 45 f4             	mov    %eax,-0xc(%ebp)
	cprintf("kernel warning at %s:%d:\n    ", file, line);
  100a87:	8b 45 0c             	mov    0xc(%ebp),%eax
  100a8a:	89 44 24 08          	mov    %eax,0x8(%esp)
  100a8e:	8b 45 08             	mov    0x8(%ebp),%eax
  100a91:	89 44 24 04          	mov    %eax,0x4(%esp)
  100a95:	c7 04 24 f4 32 10 00 	movl   $0x1032f4,(%esp)
  100a9c:	e8 cf f6 ff ff       	call   100170 <cprintf>
	vcprintf(fmt, ap);
  100aa1:	8b 45 10             	mov    0x10(%ebp),%eax
  100aa4:	8b 55 f4             	mov    -0xc(%ebp),%edx
  100aa7:	89 54 24 04          	mov    %edx,0x4(%esp)
  100aab:	89 04 24             	mov    %eax,(%esp)
  100aae:	e8 89 f6 ff ff       	call   10013c <vcprintf>
	cprintf("\n");
  100ab3:	c7 04 24 f2 32 10 00 	movl   $0x1032f2,(%esp)
  100aba:	e8 b1 f6 ff ff       	call   100170 <cprintf>
	va_end(ap);
}
  100abf:	c9                   	leave  
  100ac0:	c3                   	ret    

00100ac1 <is_kernel_panic>:

bool
is_kernel_panic(void) {
  100ac1:	55                   	push   %ebp
  100ac2:	89 e5                	mov    %esp,%ebp
	return is_panic;
  100ac4:	a1 e0 dd 10 00       	mov    0x10dde0,%eax
}
  100ac9:	5d                   	pop    %ebp
  100aca:	c3                   	ret    
	...

00100acc <clock_init>:
/* *
 * clock_init - initialize 8253 clock to interrupt 100 times per second,
 * and then enable IRQ_TIMER.
 * */
void
clock_init(void) {
  100acc:	55                   	push   %ebp
  100acd:	89 e5                	mov    %esp,%ebp
  100acf:	83 ec 28             	sub    $0x28,%esp
  100ad2:	66 c7 45 ee 43 00    	movw   $0x43,-0x12(%ebp)
  100ad8:	c6 45 ed 34          	movb   $0x34,-0x13(%ebp)
			: "memory", "cc");
}

static inline void
outb(uint16_t port, uint8_t data) {
	asm volatile ("outb %0, %1" :: "a" (data), "d" (port));
  100adc:	0f b6 45 ed          	movzbl -0x13(%ebp),%eax
  100ae0:	0f b7 55 ee          	movzwl -0x12(%ebp),%edx
  100ae4:	ee                   	out    %al,(%dx)
  100ae5:	66 c7 45 f2 40 00    	movw   $0x40,-0xe(%ebp)
  100aeb:	c6 45 f1 9c          	movb   $0x9c,-0xf(%ebp)
  100aef:	0f b6 45 f1          	movzbl -0xf(%ebp),%eax
  100af3:	0f b7 55 f2          	movzwl -0xe(%ebp),%edx
  100af7:	ee                   	out    %al,(%dx)
  100af8:	66 c7 45 f6 40 00    	movw   $0x40,-0xa(%ebp)
  100afe:	c6 45 f5 2e          	movb   $0x2e,-0xb(%ebp)
  100b02:	0f b6 45 f5          	movzbl -0xb(%ebp),%eax
  100b06:	0f b7 55 f6          	movzwl -0xa(%ebp),%edx
  100b0a:	ee                   	out    %al,(%dx)
	outb(TIMER_MODE, TIMER_SEL0 | TIMER_RATEGEN | TIMER_16BIT);
	outb(IO_TIMER1, TIMER_DIV(100) % 256);
	outb(IO_TIMER1, TIMER_DIV(100) / 256);

	// initialize time counter 'ticks' to zero
	ticks = 0;
  100b0b:	c7 05 60 e8 10 00 00 	movl   $0x0,0x10e860
  100b12:	00 00 00 

	cprintf("++ setup timer interrupts\n");
  100b15:	c7 04 24 12 33 10 00 	movl   $0x103312,(%esp)
  100b1c:	e8 4f f6 ff ff       	call   100170 <cprintf>
	pic_enable(IRQ_TIMER);
  100b21:	c7 04 24 00 00 00 00 	movl   $0x0,(%esp)
  100b28:	e8 bf 08 00 00       	call   1013ec <pic_enable>
}
  100b2d:	c9                   	leave  
  100b2e:	c3                   	ret    
	...

00100b30 <delay>:
#include <picirq.h>
#include <trap.h>

/* stupid I/O delay routine necessitated by historical PC design flaws */
static void
delay(void) {
  100b30:	55                   	push   %ebp
  100b31:	89 e5                	mov    %esp,%ebp
  100b33:	83 ec 10             	sub    $0x10,%esp
  100b36:	66 c7 45 f0 84 00    	movw   $0x84,-0x10(%ebp)
static inline void cli(void) __attribute__((always_inline));

static inline uint8_t
inb(uint16_t port) {
	uint8_t data;
	asm volatile ("inb %1, %0" : "=a" (data) : "d" (port));
  100b3c:	0f b7 45 f0          	movzwl -0x10(%ebp),%eax
  100b40:	89 c2                	mov    %eax,%edx
  100b42:	ec                   	in     (%dx),%al
  100b43:	88 45 f3             	mov    %al,-0xd(%ebp)
	return data;
  100b46:	66 c7 45 f4 84 00    	movw   $0x84,-0xc(%ebp)
static inline void cli(void) __attribute__((always_inline));

static inline uint8_t
inb(uint16_t port) {
	uint8_t data;
	asm volatile ("inb %1, %0" : "=a" (data) : "d" (port));
  100b4c:	0f b7 45 f4          	movzwl -0xc(%ebp),%eax
  100b50:	89 c2                	mov    %eax,%edx
  100b52:	ec                   	in     (%dx),%al
  100b53:	88 45 f7             	mov    %al,-0x9(%ebp)
	return data;
  100b56:	66 c7 45 f8 84 00    	movw   $0x84,-0x8(%ebp)
static inline void cli(void) __attribute__((always_inline));

static inline uint8_t
inb(uint16_t port) {
	uint8_t data;
	asm volatile ("inb %1, %0" : "=a" (data) : "d" (port));
  100b5c:	0f b7 45 f8          	movzwl -0x8(%ebp),%eax
  100b60:	89 c2                	mov    %eax,%edx
  100b62:	ec                   	in     (%dx),%al
  100b63:	88 45 fb             	mov    %al,-0x5(%ebp)
	return data;
  100b66:	66 c7 45 fc 84 00    	movw   $0x84,-0x4(%ebp)
static inline void cli(void) __attribute__((always_inline));

static inline uint8_t
inb(uint16_t port) {
	uint8_t data;
	asm volatile ("inb %1, %0" : "=a" (data) : "d" (port));
  100b6c:	0f b7 45 fc          	movzwl -0x4(%ebp),%eax
  100b70:	89 c2                	mov    %eax,%edx
  100b72:	ec                   	in     (%dx),%al
  100b73:	88 45 ff             	mov    %al,-0x1(%ebp)
	inb(0x84);
	inb(0x84);
	inb(0x84);
	inb(0x84);
}
  100b76:	c9                   	leave  
  100b77:	c3                   	ret    

00100b78 <cga_init>:
static uint16_t addr_6845;

/* TEXT-mode CGA/VGA display output */

static void
cga_init(void) {
  100b78:	55                   	push   %ebp
  100b79:	89 e5                	mov    %esp,%ebp
  100b7b:	83 ec 20             	sub    $0x20,%esp
	volatile uint16_t *cp = (uint16_t *)CGA_BUF;
  100b7e:	c7 45 e4 00 80 0b 00 	movl   $0xb8000,-0x1c(%ebp)
	uint16_t was = *cp;
  100b85:	8b 45 e4             	mov    -0x1c(%ebp),%eax
  100b88:	0f b7 00             	movzwl (%eax),%eax
  100b8b:	66 89 45 ea          	mov    %ax,-0x16(%ebp)
	*cp = (uint16_t) 0xA55A;
  100b8f:	8b 45 e4             	mov    -0x1c(%ebp),%eax
  100b92:	66 c7 00 5a a5       	movw   $0xa55a,(%eax)
	if (*cp != 0xA55A) {
  100b97:	8b 45 e4             	mov    -0x1c(%ebp),%eax
  100b9a:	0f b7 00             	movzwl (%eax),%eax
  100b9d:	66 3d 5a a5          	cmp    $0xa55a,%ax
  100ba1:	74 12                	je     100bb5 <cga_init+0x3d>
		cp = (uint16_t*)MONO_BUF;
  100ba3:	c7 45 e4 00 00 0b 00 	movl   $0xb0000,-0x1c(%ebp)
		addr_6845 = MONO_BASE;
  100baa:	66 c7 05 06 de 10 00 	movw   $0x3b4,0x10de06
  100bb1:	b4 03 
  100bb3:	eb 13                	jmp    100bc8 <cga_init+0x50>
	} else {
		*cp = was;
  100bb5:	8b 45 e4             	mov    -0x1c(%ebp),%eax
  100bb8:	0f b7 55 ea          	movzwl -0x16(%ebp),%edx
  100bbc:	66 89 10             	mov    %dx,(%eax)
		addr_6845 = CGA_BASE;
  100bbf:	66 c7 05 06 de 10 00 	movw   $0x3d4,0x10de06
  100bc6:	d4 03 
	}

	// Extract cursor location
	uint32_t pos;
	outb(addr_6845, 14);
  100bc8:	0f b7 05 06 de 10 00 	movzwl 0x10de06,%eax
  100bcf:	0f b7 c0             	movzwl %ax,%eax
  100bd2:	66 89 45 f4          	mov    %ax,-0xc(%ebp)
  100bd6:	c6 45 f3 0e          	movb   $0xe,-0xd(%ebp)
			: "memory", "cc");
}

static inline void
outb(uint16_t port, uint8_t data) {
	asm volatile ("outb %0, %1" :: "a" (data), "d" (port));
  100bda:	0f b6 45 f3          	movzbl -0xd(%ebp),%eax
  100bde:	0f b7 55 f4          	movzwl -0xc(%ebp),%edx
  100be2:	ee                   	out    %al,(%dx)
	pos = inb(addr_6845 + 1) << 8;
  100be3:	0f b7 05 06 de 10 00 	movzwl 0x10de06,%eax
  100bea:	83 c0 01             	add    $0x1,%eax
  100bed:	0f b7 c0             	movzwl %ax,%eax
  100bf0:	66 89 45 f6          	mov    %ax,-0xa(%ebp)
static inline void cli(void) __attribute__((always_inline));

static inline uint8_t
inb(uint16_t port) {
	uint8_t data;
	asm volatile ("inb %1, %0" : "=a" (data) : "d" (port));
  100bf4:	0f b7 45 f6          	movzwl -0xa(%ebp),%eax
  100bf8:	89 c2                	mov    %eax,%edx
  100bfa:	ec                   	in     (%dx),%al
  100bfb:	88 45 f8             	mov    %al,-0x8(%ebp)
	return data;
  100bfe:	0f b6 45 f8          	movzbl -0x8(%ebp),%eax
  100c02:	0f b6 c0             	movzbl %al,%eax
  100c05:	c1 e0 08             	shl    $0x8,%eax
  100c08:	89 45 ec             	mov    %eax,-0x14(%ebp)
	outb(addr_6845, 15);
  100c0b:	0f b7 05 06 de 10 00 	movzwl 0x10de06,%eax
  100c12:	0f b7 c0             	movzwl %ax,%eax
  100c15:	66 89 45 fa          	mov    %ax,-0x6(%ebp)
  100c19:	c6 45 f9 0f          	movb   $0xf,-0x7(%ebp)
			: "memory", "cc");
}

static inline void
outb(uint16_t port, uint8_t data) {
	asm volatile ("outb %0, %1" :: "a" (data), "d" (port));
  100c1d:	0f b6 45 f9          	movzbl -0x7(%ebp),%eax
  100c21:	0f b7 55 fa          	movzwl -0x6(%ebp),%edx
  100c25:	ee                   	out    %al,(%dx)
	pos |= inb(addr_6845 + 1);
  100c26:	0f b7 05 06 de 10 00 	movzwl 0x10de06,%eax
  100c2d:	83 c0 01             	add    $0x1,%eax
  100c30:	0f b7 c0             	movzwl %ax,%eax
  100c33:	66 89 45 fc          	mov    %ax,-0x4(%ebp)
static inline void cli(void) __attribute__((always_inline));

static inline uint8_t
inb(uint16_t port) {
	uint8_t data;
	asm volatile ("inb %1, %0" : "=a" (data) : "d" (port));
  100c37:	0f b7 45 fc          	movzwl -0x4(%ebp),%eax
  100c3b:	89 c2                	mov    %eax,%edx
  100c3d:	ec                   	in     (%dx),%al
  100c3e:	88 45 ff             	mov    %al,-0x1(%ebp)
	return data;
  100c41:	0f b6 45 ff          	movzbl -0x1(%ebp),%eax
  100c45:	0f b6 c0             	movzbl %al,%eax
  100c48:	09 45 ec             	or     %eax,-0x14(%ebp)

	crt_buf = (uint16_t*) cp;
  100c4b:	8b 45 e4             	mov    -0x1c(%ebp),%eax
  100c4e:	a3 00 de 10 00       	mov    %eax,0x10de00
	crt_pos = pos;
  100c53:	8b 45 ec             	mov    -0x14(%ebp),%eax
  100c56:	66 a3 04 de 10 00    	mov    %ax,0x10de04
}
  100c5c:	c9                   	leave  
  100c5d:	c3                   	ret    

00100c5e <serial_init>:

static bool serial_exists = 0;

static void
serial_init(void) {
  100c5e:	55                   	push   %ebp
  100c5f:	89 e5                	mov    %esp,%ebp
  100c61:	83 ec 48             	sub    $0x48,%esp
  100c64:	66 c7 45 d2 fa 03    	movw   $0x3fa,-0x2e(%ebp)
  100c6a:	c6 45 d1 00          	movb   $0x0,-0x2f(%ebp)
			: "memory", "cc");
}

static inline void
outb(uint16_t port, uint8_t data) {
	asm volatile ("outb %0, %1" :: "a" (data), "d" (port));
  100c6e:	0f b6 45 d1          	movzbl -0x2f(%ebp),%eax
  100c72:	0f b7 55 d2          	movzwl -0x2e(%ebp),%edx
  100c76:	ee                   	out    %al,(%dx)
  100c77:	66 c7 45 d6 fb 03    	movw   $0x3fb,-0x2a(%ebp)
  100c7d:	c6 45 d5 80          	movb   $0x80,-0x2b(%ebp)
  100c81:	0f b6 45 d5          	movzbl -0x2b(%ebp),%eax
  100c85:	0f b7 55 d6          	movzwl -0x2a(%ebp),%edx
  100c89:	ee                   	out    %al,(%dx)
  100c8a:	66 c7 45 da f8 03    	movw   $0x3f8,-0x26(%ebp)
  100c90:	c6 45 d9 0c          	movb   $0xc,-0x27(%ebp)
  100c94:	0f b6 45 d9          	movzbl -0x27(%ebp),%eax
  100c98:	0f b7 55 da          	movzwl -0x26(%ebp),%edx
  100c9c:	ee                   	out    %al,(%dx)
  100c9d:	66 c7 45 de f9 03    	movw   $0x3f9,-0x22(%ebp)
  100ca3:	c6 45 dd 00          	movb   $0x0,-0x23(%ebp)
  100ca7:	0f b6 45 dd          	movzbl -0x23(%ebp),%eax
  100cab:	0f b7 55 de          	movzwl -0x22(%ebp),%edx
  100caf:	ee                   	out    %al,(%dx)
  100cb0:	66 c7 45 e2 fb 03    	movw   $0x3fb,-0x1e(%ebp)
  100cb6:	c6 45 e1 03          	movb   $0x3,-0x1f(%ebp)
  100cba:	0f b6 45 e1          	movzbl -0x1f(%ebp),%eax
  100cbe:	0f b7 55 e2          	movzwl -0x1e(%ebp),%edx
  100cc2:	ee                   	out    %al,(%dx)
  100cc3:	66 c7 45 e6 fc 03    	movw   $0x3fc,-0x1a(%ebp)
  100cc9:	c6 45 e5 00          	movb   $0x0,-0x1b(%ebp)
  100ccd:	0f b6 45 e5          	movzbl -0x1b(%ebp),%eax
  100cd1:	0f b7 55 e6          	movzwl -0x1a(%ebp),%edx
  100cd5:	ee                   	out    %al,(%dx)
  100cd6:	66 c7 45 ea f9 03    	movw   $0x3f9,-0x16(%ebp)
  100cdc:	c6 45 e9 01          	movb   $0x1,-0x17(%ebp)
  100ce0:	0f b6 45 e9          	movzbl -0x17(%ebp),%eax
  100ce4:	0f b7 55 ea          	movzwl -0x16(%ebp),%edx
  100ce8:	ee                   	out    %al,(%dx)
  100ce9:	66 c7 45 ec fd 03    	movw   $0x3fd,-0x14(%ebp)
static inline void cli(void) __attribute__((always_inline));

static inline uint8_t
inb(uint16_t port) {
	uint8_t data;
	asm volatile ("inb %1, %0" : "=a" (data) : "d" (port));
  100cef:	0f b7 45 ec          	movzwl -0x14(%ebp),%eax
  100cf3:	89 c2                	mov    %eax,%edx
  100cf5:	ec                   	in     (%dx),%al
  100cf6:	88 45 ef             	mov    %al,-0x11(%ebp)
	return data;
  100cf9:	0f b6 45 ef          	movzbl -0x11(%ebp),%eax
	// Enable rcv interrupts
	outb(COM1 + COM_IER, COM_IER_RDI);

	// Clear any preexisting overrun indications and interrupts
	// Serial port doesn't exist if COM_LSR returns 0xFF
	serial_exists = (inb(COM1 + COM_LSR) != 0xFF);
  100cfd:	3c ff                	cmp    $0xff,%al
  100cff:	0f 95 c0             	setne  %al
  100d02:	0f b6 c0             	movzbl %al,%eax
  100d05:	a3 08 de 10 00       	mov    %eax,0x10de08
  100d0a:	66 c7 45 f0 fa 03    	movw   $0x3fa,-0x10(%ebp)
static inline void cli(void) __attribute__((always_inline));

static inline uint8_t
inb(uint16_t port) {
	uint8_t data;
	asm volatile ("inb %1, %0" : "=a" (data) : "d" (port));
  100d10:	0f b7 45 f0          	movzwl -0x10(%ebp),%eax
  100d14:	89 c2                	mov    %eax,%edx
  100d16:	ec                   	in     (%dx),%al
  100d17:	88 45 f3             	mov    %al,-0xd(%ebp)
	return data;
  100d1a:	66 c7 45 f4 f8 03    	movw   $0x3f8,-0xc(%ebp)
static inline void cli(void) __attribute__((always_inline));

static inline uint8_t
inb(uint16_t port) {
	uint8_t data;
	asm volatile ("inb %1, %0" : "=a" (data) : "d" (port));
  100d20:	0f b7 45 f4          	movzwl -0xc(%ebp),%eax
  100d24:	89 c2                	mov    %eax,%edx
  100d26:	ec                   	in     (%dx),%al
  100d27:	88 45 f7             	mov    %al,-0x9(%ebp)
	(void) inb(COM1+COM_IIR);
	(void) inb(COM1+COM_RX);

	if (serial_exists) {
  100d2a:	a1 08 de 10 00       	mov    0x10de08,%eax
  100d2f:	85 c0                	test   %eax,%eax
  100d31:	74 0c                	je     100d3f <serial_init+0xe1>
		pic_enable(IRQ_COM1);
  100d33:	c7 04 24 04 00 00 00 	movl   $0x4,(%esp)
  100d3a:	e8 ad 06 00 00       	call   1013ec <pic_enable>
	}
}
  100d3f:	c9                   	leave  
  100d40:	c3                   	ret    

00100d41 <lpt_putc_sub>:

static void
lpt_putc_sub(int c) {
  100d41:	55                   	push   %ebp
  100d42:	89 e5                	mov    %esp,%ebp
  100d44:	83 ec 20             	sub    $0x20,%esp
	int i;
	for (i = 0; !(inb(LPTPORT + 1) & 0x80) && i < 12800; i ++) {
  100d47:	c7 45 ec 00 00 00 00 	movl   $0x0,-0x14(%ebp)
  100d4e:	eb 09                	jmp    100d59 <lpt_putc_sub+0x18>
		delay();
  100d50:	e8 db fd ff ff       	call   100b30 <delay>
}

static void
lpt_putc_sub(int c) {
	int i;
	for (i = 0; !(inb(LPTPORT + 1) & 0x80) && i < 12800; i ++) {
  100d55:	83 45 ec 01          	addl   $0x1,-0x14(%ebp)
  100d59:	66 c7 45 f2 79 03    	movw   $0x379,-0xe(%ebp)
  100d5f:	0f b7 45 f2          	movzwl -0xe(%ebp),%eax
  100d63:	89 c2                	mov    %eax,%edx
  100d65:	ec                   	in     (%dx),%al
  100d66:	88 45 f4             	mov    %al,-0xc(%ebp)
	return data;
  100d69:	0f b6 45 f4          	movzbl -0xc(%ebp),%eax
  100d6d:	84 c0                	test   %al,%al
  100d6f:	78 09                	js     100d7a <lpt_putc_sub+0x39>
  100d71:	81 7d ec ff 31 00 00 	cmpl   $0x31ff,-0x14(%ebp)
  100d78:	7e d6                	jle    100d50 <lpt_putc_sub+0xf>
		delay();
	}
	outb(LPTPORT + 0, c);
  100d7a:	8b 45 08             	mov    0x8(%ebp),%eax
  100d7d:	0f b6 c0             	movzbl %al,%eax
  100d80:	66 c7 45 f6 78 03    	movw   $0x378,-0xa(%ebp)
  100d86:	88 45 f5             	mov    %al,-0xb(%ebp)
			: "memory", "cc");
}

static inline void
outb(uint16_t port, uint8_t data) {
	asm volatile ("outb %0, %1" :: "a" (data), "d" (port));
  100d89:	0f b6 45 f5          	movzbl -0xb(%ebp),%eax
  100d8d:	0f b7 55 f6          	movzwl -0xa(%ebp),%edx
  100d91:	ee                   	out    %al,(%dx)
  100d92:	66 c7 45 fa 7a 03    	movw   $0x37a,-0x6(%ebp)
  100d98:	c6 45 f9 0d          	movb   $0xd,-0x7(%ebp)
  100d9c:	0f b6 45 f9          	movzbl -0x7(%ebp),%eax
  100da0:	0f b7 55 fa          	movzwl -0x6(%ebp),%edx
  100da4:	ee                   	out    %al,(%dx)
  100da5:	66 c7 45 fe 7a 03    	movw   $0x37a,-0x2(%ebp)
  100dab:	c6 45 fd 08          	movb   $0x8,-0x3(%ebp)
  100daf:	0f b6 45 fd          	movzbl -0x3(%ebp),%eax
  100db3:	0f b7 55 fe          	movzwl -0x2(%ebp),%edx
  100db7:	ee                   	out    %al,(%dx)
	outb(LPTPORT + 2, 0x08 | 0x04 | 0x01);
	outb(LPTPORT + 2, 0x08);
}
  100db8:	c9                   	leave  
  100db9:	c3                   	ret    

00100dba <lpt_putc>:

/* lpt_putc - copy console output to parallel port */
static void
lpt_putc(int c) {
  100dba:	55                   	push   %ebp
  100dbb:	89 e5                	mov    %esp,%ebp
  100dbd:	83 ec 04             	sub    $0x4,%esp
	if (c != '\b') {
  100dc0:	83 7d 08 08          	cmpl   $0x8,0x8(%ebp)
  100dc4:	74 0d                	je     100dd3 <lpt_putc+0x19>
		lpt_putc_sub(c);
  100dc6:	8b 45 08             	mov    0x8(%ebp),%eax
  100dc9:	89 04 24             	mov    %eax,(%esp)
  100dcc:	e8 70 ff ff ff       	call   100d41 <lpt_putc_sub>
  100dd1:	eb 24                	jmp    100df7 <lpt_putc+0x3d>
	}
	else {
		lpt_putc_sub('\b');
  100dd3:	c7 04 24 08 00 00 00 	movl   $0x8,(%esp)
  100dda:	e8 62 ff ff ff       	call   100d41 <lpt_putc_sub>
		lpt_putc_sub(' ');
  100ddf:	c7 04 24 20 00 00 00 	movl   $0x20,(%esp)
  100de6:	e8 56 ff ff ff       	call   100d41 <lpt_putc_sub>
		lpt_putc_sub('\b');
  100deb:	c7 04 24 08 00 00 00 	movl   $0x8,(%esp)
  100df2:	e8 4a ff ff ff       	call   100d41 <lpt_putc_sub>
	}
}
  100df7:	c9                   	leave  
  100df8:	c3                   	ret    

00100df9 <cga_putc>:

/* cga_putc - print character to console */
static void
cga_putc(int c) {
  100df9:	55                   	push   %ebp
  100dfa:	89 e5                	mov    %esp,%ebp
  100dfc:	53                   	push   %ebx
  100dfd:	83 ec 34             	sub    $0x34,%esp
	// set black on white
	if (!(c & ~0xFF)) {
  100e00:	8b 45 08             	mov    0x8(%ebp),%eax
  100e03:	b0 00                	mov    $0x0,%al
  100e05:	85 c0                	test   %eax,%eax
  100e07:	75 07                	jne    100e10 <cga_putc+0x17>
		c |= 0x0700;
  100e09:	81 4d 08 00 07 00 00 	orl    $0x700,0x8(%ebp)
	}

	switch (c & 0xff) {
  100e10:	8b 45 08             	mov    0x8(%ebp),%eax
  100e13:	25 ff 00 00 00       	and    $0xff,%eax
  100e18:	83 f8 0a             	cmp    $0xa,%eax
  100e1b:	74 4f                	je     100e6c <cga_putc+0x73>
  100e1d:	83 f8 0d             	cmp    $0xd,%eax
  100e20:	74 5a                	je     100e7c <cga_putc+0x83>
  100e22:	83 f8 08             	cmp    $0x8,%eax
  100e25:	0f 85 8d 00 00 00    	jne    100eb8 <cga_putc+0xbf>
	case '\b':
		if (crt_pos > 0) {
  100e2b:	0f b7 05 04 de 10 00 	movzwl 0x10de04,%eax
  100e32:	66 85 c0             	test   %ax,%ax
  100e35:	0f 84 a3 00 00 00    	je     100ede <cga_putc+0xe5>
			crt_pos --;
  100e3b:	0f b7 05 04 de 10 00 	movzwl 0x10de04,%eax
  100e42:	83 e8 01             	sub    $0x1,%eax
  100e45:	66 a3 04 de 10 00    	mov    %ax,0x10de04
			crt_buf[crt_pos] = (c & ~0xff) | ' ';
  100e4b:	a1 00 de 10 00       	mov    0x10de00,%eax
  100e50:	0f b7 15 04 de 10 00 	movzwl 0x10de04,%edx
  100e57:	0f b7 d2             	movzwl %dx,%edx
  100e5a:	01 d2                	add    %edx,%edx
  100e5c:	8d 14 10             	lea    (%eax,%edx,1),%edx
  100e5f:	8b 45 08             	mov    0x8(%ebp),%eax
  100e62:	b0 00                	mov    $0x0,%al
  100e64:	83 c8 20             	or     $0x20,%eax
  100e67:	66 89 02             	mov    %ax,(%edx)
		}
		break;
  100e6a:	eb 73                	jmp    100edf <cga_putc+0xe6>
	case '\n':
		crt_pos += CRT_COLS;
  100e6c:	0f b7 05 04 de 10 00 	movzwl 0x10de04,%eax
  100e73:	83 c0 50             	add    $0x50,%eax
  100e76:	66 a3 04 de 10 00    	mov    %ax,0x10de04
	case '\r':
		crt_pos -= (crt_pos % CRT_COLS);
  100e7c:	0f b7 1d 04 de 10 00 	movzwl 0x10de04,%ebx
  100e83:	0f b7 0d 04 de 10 00 	movzwl 0x10de04,%ecx
  100e8a:	0f b7 c1             	movzwl %cx,%eax
  100e8d:	69 c0 cd cc 00 00    	imul   $0xcccd,%eax,%eax
  100e93:	c1 e8 10             	shr    $0x10,%eax
  100e96:	89 c2                	mov    %eax,%edx
  100e98:	66 c1 ea 06          	shr    $0x6,%dx
  100e9c:	89 d0                	mov    %edx,%eax
  100e9e:	c1 e0 02             	shl    $0x2,%eax
  100ea1:	01 d0                	add    %edx,%eax
  100ea3:	c1 e0 04             	shl    $0x4,%eax
  100ea6:	89 ca                	mov    %ecx,%edx
  100ea8:	66 29 c2             	sub    %ax,%dx
  100eab:	89 d8                	mov    %ebx,%eax
  100ead:	66 29 d0             	sub    %dx,%ax
  100eb0:	66 a3 04 de 10 00    	mov    %ax,0x10de04
		break;
  100eb6:	eb 27                	jmp    100edf <cga_putc+0xe6>
	default:
		crt_buf[crt_pos ++] = c;     // write the character
  100eb8:	8b 15 00 de 10 00    	mov    0x10de00,%edx
  100ebe:	0f b7 05 04 de 10 00 	movzwl 0x10de04,%eax
  100ec5:	0f b7 c8             	movzwl %ax,%ecx
  100ec8:	01 c9                	add    %ecx,%ecx
  100eca:	8d 0c 0a             	lea    (%edx,%ecx,1),%ecx
  100ecd:	8b 55 08             	mov    0x8(%ebp),%edx
  100ed0:	66 89 11             	mov    %dx,(%ecx)
  100ed3:	83 c0 01             	add    $0x1,%eax
  100ed6:	66 a3 04 de 10 00    	mov    %ax,0x10de04
  100edc:	eb 01                	jmp    100edf <cga_putc+0xe6>
	case '\b':
		if (crt_pos > 0) {
			crt_pos --;
			crt_buf[crt_pos] = (c & ~0xff) | ' ';
		}
		break;
  100ede:	90                   	nop
		crt_buf[crt_pos ++] = c;     // write the character
		break;
	}

	// What is the purpose of this?
	if (crt_pos >= CRT_SIZE) {
  100edf:	0f b7 05 04 de 10 00 	movzwl 0x10de04,%eax
  100ee6:	66 3d cf 07          	cmp    $0x7cf,%ax
  100eea:	76 5b                	jbe    100f47 <cga_putc+0x14e>
		int i;
		memmove(crt_buf, crt_buf + CRT_COLS, (CRT_SIZE - CRT_COLS) * sizeof(uint16_t));
  100eec:	a1 00 de 10 00       	mov    0x10de00,%eax
  100ef1:	8d 90 a0 00 00 00    	lea    0xa0(%eax),%edx
  100ef7:	a1 00 de 10 00       	mov    0x10de00,%eax
  100efc:	c7 44 24 08 00 0f 00 	movl   $0xf00,0x8(%esp)
  100f03:	00 
  100f04:	89 54 24 04          	mov    %edx,0x4(%esp)
  100f08:	89 04 24             	mov    %eax,(%esp)
  100f0b:	e8 5a 20 00 00       	call   102f6a <memmove>
		for (i = CRT_SIZE - CRT_COLS; i < CRT_SIZE; i ++) {
  100f10:	c7 45 e4 80 07 00 00 	movl   $0x780,-0x1c(%ebp)
  100f17:	eb 15                	jmp    100f2e <cga_putc+0x135>
			crt_buf[i] = 0x0700 | ' ';
  100f19:	a1 00 de 10 00       	mov    0x10de00,%eax
  100f1e:	8b 55 e4             	mov    -0x1c(%ebp),%edx
  100f21:	01 d2                	add    %edx,%edx
  100f23:	01 d0                	add    %edx,%eax
  100f25:	66 c7 00 20 07       	movw   $0x720,(%eax)

	// What is the purpose of this?
	if (crt_pos >= CRT_SIZE) {
		int i;
		memmove(crt_buf, crt_buf + CRT_COLS, (CRT_SIZE - CRT_COLS) * sizeof(uint16_t));
		for (i = CRT_SIZE - CRT_COLS; i < CRT_SIZE; i ++) {
  100f2a:	83 45 e4 01          	addl   $0x1,-0x1c(%ebp)
  100f2e:	81 7d e4 cf 07 00 00 	cmpl   $0x7cf,-0x1c(%ebp)
  100f35:	7e e2                	jle    100f19 <cga_putc+0x120>
			crt_buf[i] = 0x0700 | ' ';
		}
		crt_pos -= CRT_COLS;
  100f37:	0f b7 05 04 de 10 00 	movzwl 0x10de04,%eax
  100f3e:	83 e8 50             	sub    $0x50,%eax
  100f41:	66 a3 04 de 10 00    	mov    %ax,0x10de04
	}

	// move that little blinky thing
	outb(addr_6845, 14);
  100f47:	0f b7 05 06 de 10 00 	movzwl 0x10de06,%eax
  100f4e:	0f b7 c0             	movzwl %ax,%eax
  100f51:	66 89 45 ea          	mov    %ax,-0x16(%ebp)
  100f55:	c6 45 e9 0e          	movb   $0xe,-0x17(%ebp)
  100f59:	0f b6 45 e9          	movzbl -0x17(%ebp),%eax
  100f5d:	0f b7 55 ea          	movzwl -0x16(%ebp),%edx
  100f61:	ee                   	out    %al,(%dx)
	outb(addr_6845 + 1, crt_pos >> 8);
  100f62:	0f b7 05 04 de 10 00 	movzwl 0x10de04,%eax
  100f69:	66 c1 e8 08          	shr    $0x8,%ax
  100f6d:	0f b6 c0             	movzbl %al,%eax
  100f70:	0f b7 15 06 de 10 00 	movzwl 0x10de06,%edx
  100f77:	83 c2 01             	add    $0x1,%edx
  100f7a:	0f b7 d2             	movzwl %dx,%edx
  100f7d:	66 89 55 ee          	mov    %dx,-0x12(%ebp)
  100f81:	88 45 ed             	mov    %al,-0x13(%ebp)
  100f84:	0f b6 45 ed          	movzbl -0x13(%ebp),%eax
  100f88:	0f b7 55 ee          	movzwl -0x12(%ebp),%edx
  100f8c:	ee                   	out    %al,(%dx)
	outb(addr_6845, 15);
  100f8d:	0f b7 05 06 de 10 00 	movzwl 0x10de06,%eax
  100f94:	0f b7 c0             	movzwl %ax,%eax
  100f97:	66 89 45 f2          	mov    %ax,-0xe(%ebp)
  100f9b:	c6 45 f1 0f          	movb   $0xf,-0xf(%ebp)
  100f9f:	0f b6 45 f1          	movzbl -0xf(%ebp),%eax
  100fa3:	0f b7 55 f2          	movzwl -0xe(%ebp),%edx
  100fa7:	ee                   	out    %al,(%dx)
	outb(addr_6845 + 1, crt_pos);
  100fa8:	0f b7 05 04 de 10 00 	movzwl 0x10de04,%eax
  100faf:	0f b6 c0             	movzbl %al,%eax
  100fb2:	0f b7 15 06 de 10 00 	movzwl 0x10de06,%edx
  100fb9:	83 c2 01             	add    $0x1,%edx
  100fbc:	0f b7 d2             	movzwl %dx,%edx
  100fbf:	66 89 55 f6          	mov    %dx,-0xa(%ebp)
  100fc3:	88 45 f5             	mov    %al,-0xb(%ebp)
  100fc6:	0f b6 45 f5          	movzbl -0xb(%ebp),%eax
  100fca:	0f b7 55 f6          	movzwl -0xa(%ebp),%edx
  100fce:	ee                   	out    %al,(%dx)
}
  100fcf:	83 c4 34             	add    $0x34,%esp
  100fd2:	5b                   	pop    %ebx
  100fd3:	5d                   	pop    %ebp
  100fd4:	c3                   	ret    

00100fd5 <serial_putc_sub>:

static void
serial_putc_sub(int c) {
  100fd5:	55                   	push   %ebp
  100fd6:	89 e5                	mov    %esp,%ebp
  100fd8:	83 ec 10             	sub    $0x10,%esp
    int i;
	for (i = 0; !(inb(COM1 + COM_LSR) & COM_LSR_TXRDY) && i < 12800; i ++) {
  100fdb:	c7 45 f4 00 00 00 00 	movl   $0x0,-0xc(%ebp)
  100fe2:	eb 09                	jmp    100fed <serial_putc_sub+0x18>
		delay();
  100fe4:	e8 47 fb ff ff       	call   100b30 <delay>
}

static void
serial_putc_sub(int c) {
    int i;
	for (i = 0; !(inb(COM1 + COM_LSR) & COM_LSR_TXRDY) && i < 12800; i ++) {
  100fe9:	83 45 f4 01          	addl   $0x1,-0xc(%ebp)
  100fed:	66 c7 45 fa fd 03    	movw   $0x3fd,-0x6(%ebp)
static inline void cli(void) __attribute__((always_inline));

static inline uint8_t
inb(uint16_t port) {
	uint8_t data;
	asm volatile ("inb %1, %0" : "=a" (data) : "d" (port));
  100ff3:	0f b7 45 fa          	movzwl -0x6(%ebp),%eax
  100ff7:	89 c2                	mov    %eax,%edx
  100ff9:	ec                   	in     (%dx),%al
  100ffa:	88 45 fc             	mov    %al,-0x4(%ebp)
	return data;
  100ffd:	0f b6 45 fc          	movzbl -0x4(%ebp),%eax
  101001:	0f b6 c0             	movzbl %al,%eax
  101004:	83 e0 20             	and    $0x20,%eax
  101007:	85 c0                	test   %eax,%eax
  101009:	75 09                	jne    101014 <serial_putc_sub+0x3f>
  10100b:	81 7d f4 ff 31 00 00 	cmpl   $0x31ff,-0xc(%ebp)
  101012:	7e d0                	jle    100fe4 <serial_putc_sub+0xf>
		delay();
	}
	outb(COM1 + COM_TX, c);
  101014:	8b 45 08             	mov    0x8(%ebp),%eax
  101017:	0f b6 c0             	movzbl %al,%eax
  10101a:	66 c7 45 fe f8 03    	movw   $0x3f8,-0x2(%ebp)
  101020:	88 45 fd             	mov    %al,-0x3(%ebp)
			: "memory", "cc");
}

static inline void
outb(uint16_t port, uint8_t data) {
	asm volatile ("outb %0, %1" :: "a" (data), "d" (port));
  101023:	0f b6 45 fd          	movzbl -0x3(%ebp),%eax
  101027:	0f b7 55 fe          	movzwl -0x2(%ebp),%edx
  10102b:	ee                   	out    %al,(%dx)
}
  10102c:	c9                   	leave  
  10102d:	c3                   	ret    

0010102e <serial_putc>:

/* serial_putc - print character to serial port */
static void
serial_putc(int c) {
  10102e:	55                   	push   %ebp
  10102f:	89 e5                	mov    %esp,%ebp
  101031:	83 ec 04             	sub    $0x4,%esp
	if (c != '\b') {
  101034:	83 7d 08 08          	cmpl   $0x8,0x8(%ebp)
  101038:	74 0d                	je     101047 <serial_putc+0x19>
		serial_putc_sub(c);
  10103a:	8b 45 08             	mov    0x8(%ebp),%eax
  10103d:	89 04 24             	mov    %eax,(%esp)
  101040:	e8 90 ff ff ff       	call   100fd5 <serial_putc_sub>
  101045:	eb 24                	jmp    10106b <serial_putc+0x3d>
	}
	else {
		serial_putc_sub('\b');
  101047:	c7 04 24 08 00 00 00 	movl   $0x8,(%esp)
  10104e:	e8 82 ff ff ff       	call   100fd5 <serial_putc_sub>
		serial_putc_sub(' ');
  101053:	c7 04 24 20 00 00 00 	movl   $0x20,(%esp)
  10105a:	e8 76 ff ff ff       	call   100fd5 <serial_putc_sub>
		serial_putc_sub('\b');
  10105f:	c7 04 24 08 00 00 00 	movl   $0x8,(%esp)
  101066:	e8 6a ff ff ff       	call   100fd5 <serial_putc_sub>
	}
}
  10106b:	c9                   	leave  
  10106c:	c3                   	ret    

0010106d <cons_intr>:
/* *
 * cons_intr - called by device interrupt routines to feed input
 * characters into the circular console input buffer.
 * */
static void
cons_intr(int (*proc)(void)) {
  10106d:	55                   	push   %ebp
  10106e:	89 e5                	mov    %esp,%ebp
  101070:	83 ec 18             	sub    $0x18,%esp
	int c;
	while ((c = (*proc)()) != -1) {
  101073:	eb 32                	jmp    1010a7 <cons_intr+0x3a>
		if (c != 0) {
  101075:	83 7d f4 00          	cmpl   $0x0,-0xc(%ebp)
  101079:	74 2c                	je     1010a7 <cons_intr+0x3a>
			cons.buf[cons.wpos ++] = c;
  10107b:	a1 24 e0 10 00       	mov    0x10e024,%eax
  101080:	8b 55 f4             	mov    -0xc(%ebp),%edx
  101083:	88 90 20 de 10 00    	mov    %dl,0x10de20(%eax)
  101089:	83 c0 01             	add    $0x1,%eax
  10108c:	a3 24 e0 10 00       	mov    %eax,0x10e024
			if (cons.wpos == CONSBUFSIZE) {
  101091:	a1 24 e0 10 00       	mov    0x10e024,%eax
  101096:	3d 00 02 00 00       	cmp    $0x200,%eax
  10109b:	75 0a                	jne    1010a7 <cons_intr+0x3a>
				cons.wpos = 0;
  10109d:	c7 05 24 e0 10 00 00 	movl   $0x0,0x10e024
  1010a4:	00 00 00 
 * characters into the circular console input buffer.
 * */
static void
cons_intr(int (*proc)(void)) {
	int c;
	while ((c = (*proc)()) != -1) {
  1010a7:	8b 45 08             	mov    0x8(%ebp),%eax
  1010aa:	ff d0                	call   *%eax
  1010ac:	89 45 f4             	mov    %eax,-0xc(%ebp)
  1010af:	83 7d f4 ff          	cmpl   $0xffffffff,-0xc(%ebp)
  1010b3:	75 c0                	jne    101075 <cons_intr+0x8>
			if (cons.wpos == CONSBUFSIZE) {
				cons.wpos = 0;
			}
		}
	}
}
  1010b5:	c9                   	leave  
  1010b6:	c3                   	ret    

001010b7 <serial_proc_data>:

/* serial_proc_data - get data from serial port */
static int
serial_proc_data(void) {
  1010b7:	55                   	push   %ebp
  1010b8:	89 e5                	mov    %esp,%ebp
  1010ba:	83 ec 10             	sub    $0x10,%esp
  1010bd:	66 c7 45 f8 fd 03    	movw   $0x3fd,-0x8(%ebp)
static inline void cli(void) __attribute__((always_inline));

static inline uint8_t
inb(uint16_t port) {
	uint8_t data;
	asm volatile ("inb %1, %0" : "=a" (data) : "d" (port));
  1010c3:	0f b7 45 f8          	movzwl -0x8(%ebp),%eax
  1010c7:	89 c2                	mov    %eax,%edx
  1010c9:	ec                   	in     (%dx),%al
  1010ca:	88 45 fb             	mov    %al,-0x5(%ebp)
	return data;
  1010cd:	0f b6 45 fb          	movzbl -0x5(%ebp),%eax
	if (!(inb(COM1 + COM_LSR) & COM_LSR_DATA)) {
  1010d1:	0f b6 c0             	movzbl %al,%eax
  1010d4:	83 e0 01             	and    $0x1,%eax
  1010d7:	85 c0                	test   %eax,%eax
  1010d9:	75 07                	jne    1010e2 <serial_proc_data+0x2b>
		return -1;
  1010db:	b8 ff ff ff ff       	mov    $0xffffffff,%eax
  1010e0:	eb 2a                	jmp    10110c <serial_proc_data+0x55>
  1010e2:	66 c7 45 fc f8 03    	movw   $0x3f8,-0x4(%ebp)
static inline void cli(void) __attribute__((always_inline));

static inline uint8_t
inb(uint16_t port) {
	uint8_t data;
	asm volatile ("inb %1, %0" : "=a" (data) : "d" (port));
  1010e8:	0f b7 45 fc          	movzwl -0x4(%ebp),%eax
  1010ec:	89 c2                	mov    %eax,%edx
  1010ee:	ec                   	in     (%dx),%al
  1010ef:	88 45 ff             	mov    %al,-0x1(%ebp)
	return data;
  1010f2:	0f b6 45 ff          	movzbl -0x1(%ebp),%eax
	}
	int c = inb(COM1 + COM_RX);
  1010f6:	0f b6 c0             	movzbl %al,%eax
  1010f9:	89 45 f4             	mov    %eax,-0xc(%ebp)
	if (c == 127) {
  1010fc:	83 7d f4 7f          	cmpl   $0x7f,-0xc(%ebp)
  101100:	75 07                	jne    101109 <serial_proc_data+0x52>
		c = '\b';
  101102:	c7 45 f4 08 00 00 00 	movl   $0x8,-0xc(%ebp)
	}
	return c;
  101109:	8b 45 f4             	mov    -0xc(%ebp),%eax
}
  10110c:	c9                   	leave  
  10110d:	c3                   	ret    

0010110e <serial_intr>:

/* serial_intr - try to feed input characters from serial port */
void
serial_intr(void) {
  10110e:	55                   	push   %ebp
  10110f:	89 e5                	mov    %esp,%ebp
  101111:	83 ec 18             	sub    $0x18,%esp
	if (serial_exists) {
  101114:	a1 08 de 10 00       	mov    0x10de08,%eax
  101119:	85 c0                	test   %eax,%eax
  10111b:	74 0c                	je     101129 <serial_intr+0x1b>
		cons_intr(serial_proc_data);
  10111d:	c7 04 24 b7 10 10 00 	movl   $0x1010b7,(%esp)
  101124:	e8 44 ff ff ff       	call   10106d <cons_intr>
	}
}
  101129:	c9                   	leave  
  10112a:	c3                   	ret    

0010112b <kbd_proc_data>:
 *
 * The kbd_proc_data() function gets data from the keyboard.
 * If we finish a character, return it, else 0. And return -1 if no data.
 * */
static int
kbd_proc_data(void) {
  10112b:	55                   	push   %ebp
  10112c:	89 e5                	mov    %esp,%ebp
  10112e:	83 ec 28             	sub    $0x28,%esp
  101131:	66 c7 45 ee 64 00    	movw   $0x64,-0x12(%ebp)
static inline void cli(void) __attribute__((always_inline));

static inline uint8_t
inb(uint16_t port) {
	uint8_t data;
	asm volatile ("inb %1, %0" : "=a" (data) : "d" (port));
  101137:	0f b7 45 ee          	movzwl -0x12(%ebp),%eax
  10113b:	89 c2                	mov    %eax,%edx
  10113d:	ec                   	in     (%dx),%al
  10113e:	88 45 f1             	mov    %al,-0xf(%ebp)
	return data;
  101141:	0f b6 45 f1          	movzbl -0xf(%ebp),%eax
	int c;
	uint8_t data;
	static uint32_t shift;

	if ((inb(KBSTATP) & KBS_DIB) == 0) {
  101145:	0f b6 c0             	movzbl %al,%eax
  101148:	83 e0 01             	and    $0x1,%eax
  10114b:	85 c0                	test   %eax,%eax
  10114d:	75 0a                	jne    101159 <kbd_proc_data+0x2e>
		return -1;
  10114f:	b8 ff ff ff ff       	mov    $0xffffffff,%eax
  101154:	e9 5a 01 00 00       	jmp    1012b3 <kbd_proc_data+0x188>
  101159:	66 c7 45 f2 60 00    	movw   $0x60,-0xe(%ebp)
static inline void cli(void) __attribute__((always_inline));

static inline uint8_t
inb(uint16_t port) {
	uint8_t data;
	asm volatile ("inb %1, %0" : "=a" (data) : "d" (port));
  10115f:	0f b7 45 f2          	movzwl -0xe(%ebp),%eax
  101163:	89 c2                	mov    %eax,%edx
  101165:	ec                   	in     (%dx),%al
  101166:	88 45 f4             	mov    %al,-0xc(%ebp)
	return data;
  101169:	0f b6 45 f4          	movzbl -0xc(%ebp),%eax
	}

	data = inb(KBDATAP);
  10116d:	88 45 ed             	mov    %al,-0x13(%ebp)

	if (data == 0xE0) {
  101170:	80 7d ed e0          	cmpb   $0xe0,-0x13(%ebp)
  101174:	75 17                	jne    10118d <kbd_proc_data+0x62>
		// E0 escape character
		shift |= E0ESC;
  101176:	a1 28 e0 10 00       	mov    0x10e028,%eax
  10117b:	83 c8 40             	or     $0x40,%eax
  10117e:	a3 28 e0 10 00       	mov    %eax,0x10e028
		return 0;
  101183:	b8 00 00 00 00       	mov    $0x0,%eax
  101188:	e9 26 01 00 00       	jmp    1012b3 <kbd_proc_data+0x188>
	} else if (data & 0x80) {
  10118d:	0f b6 45 ed          	movzbl -0x13(%ebp),%eax
  101191:	84 c0                	test   %al,%al
  101193:	79 47                	jns    1011dc <kbd_proc_data+0xb1>
		// Key released
		data = (shift & E0ESC ? data : data & 0x7F);
  101195:	a1 28 e0 10 00       	mov    0x10e028,%eax
  10119a:	83 e0 40             	and    $0x40,%eax
  10119d:	85 c0                	test   %eax,%eax
  10119f:	75 09                	jne    1011aa <kbd_proc_data+0x7f>
  1011a1:	0f b6 45 ed          	movzbl -0x13(%ebp),%eax
  1011a5:	83 e0 7f             	and    $0x7f,%eax
  1011a8:	eb 04                	jmp    1011ae <kbd_proc_data+0x83>
  1011aa:	0f b6 45 ed          	movzbl -0x13(%ebp),%eax
  1011ae:	88 45 ed             	mov    %al,-0x13(%ebp)
		shift &= ~(shiftcode[data] | E0ESC);
  1011b1:	0f b6 45 ed          	movzbl -0x13(%ebp),%eax
  1011b5:	0f b6 80 40 d0 10 00 	movzbl 0x10d040(%eax),%eax
  1011bc:	83 c8 40             	or     $0x40,%eax
  1011bf:	0f b6 c0             	movzbl %al,%eax
  1011c2:	f7 d0                	not    %eax
  1011c4:	89 c2                	mov    %eax,%edx
  1011c6:	a1 28 e0 10 00       	mov    0x10e028,%eax
  1011cb:	21 d0                	and    %edx,%eax
  1011cd:	a3 28 e0 10 00       	mov    %eax,0x10e028
		return 0;
  1011d2:	b8 00 00 00 00       	mov    $0x0,%eax
  1011d7:	e9 d7 00 00 00       	jmp    1012b3 <kbd_proc_data+0x188>
	} else if (shift & E0ESC) {
  1011dc:	a1 28 e0 10 00       	mov    0x10e028,%eax
  1011e1:	83 e0 40             	and    $0x40,%eax
  1011e4:	85 c0                	test   %eax,%eax
  1011e6:	74 11                	je     1011f9 <kbd_proc_data+0xce>
		// Last character was an E0 escape; or with 0x80
		data |= 0x80;
  1011e8:	80 4d ed 80          	orb    $0x80,-0x13(%ebp)
		shift &= ~E0ESC;
  1011ec:	a1 28 e0 10 00       	mov    0x10e028,%eax
  1011f1:	83 e0 bf             	and    $0xffffffbf,%eax
  1011f4:	a3 28 e0 10 00       	mov    %eax,0x10e028
	}

	shift |= shiftcode[data];
  1011f9:	0f b6 45 ed          	movzbl -0x13(%ebp),%eax
  1011fd:	0f b6 80 40 d0 10 00 	movzbl 0x10d040(%eax),%eax
  101204:	0f b6 d0             	movzbl %al,%edx
  101207:	a1 28 e0 10 00       	mov    0x10e028,%eax
  10120c:	09 d0                	or     %edx,%eax
  10120e:	a3 28 e0 10 00       	mov    %eax,0x10e028
	shift ^= togglecode[data];
  101213:	0f b6 45 ed          	movzbl -0x13(%ebp),%eax
  101217:	0f b6 80 40 d1 10 00 	movzbl 0x10d140(%eax),%eax
  10121e:	0f b6 d0             	movzbl %al,%edx
  101221:	a1 28 e0 10 00       	mov    0x10e028,%eax
  101226:	31 d0                	xor    %edx,%eax
  101228:	a3 28 e0 10 00       	mov    %eax,0x10e028

	c = charcode[shift & (CTL | SHIFT)][data];
  10122d:	a1 28 e0 10 00       	mov    0x10e028,%eax
  101232:	83 e0 03             	and    $0x3,%eax
  101235:	8b 14 85 40 d5 10 00 	mov    0x10d540(,%eax,4),%edx
  10123c:	0f b6 45 ed          	movzbl -0x13(%ebp),%eax
  101240:	8d 04 02             	lea    (%edx,%eax,1),%eax
  101243:	0f b6 00             	movzbl (%eax),%eax
  101246:	0f b6 c0             	movzbl %al,%eax
  101249:	89 45 e8             	mov    %eax,-0x18(%ebp)
	if (shift & CAPSLOCK) {
  10124c:	a1 28 e0 10 00       	mov    0x10e028,%eax
  101251:	83 e0 08             	and    $0x8,%eax
  101254:	85 c0                	test   %eax,%eax
  101256:	74 22                	je     10127a <kbd_proc_data+0x14f>
		if ('a' <= c && c <= 'z')
  101258:	83 7d e8 60          	cmpl   $0x60,-0x18(%ebp)
  10125c:	7e 0c                	jle    10126a <kbd_proc_data+0x13f>
  10125e:	83 7d e8 7a          	cmpl   $0x7a,-0x18(%ebp)
  101262:	7f 06                	jg     10126a <kbd_proc_data+0x13f>
			c += 'A' - 'a';
  101264:	83 6d e8 20          	subl   $0x20,-0x18(%ebp)
	shift |= shiftcode[data];
	shift ^= togglecode[data];

	c = charcode[shift & (CTL | SHIFT)][data];
	if (shift & CAPSLOCK) {
		if ('a' <= c && c <= 'z')
  101268:	eb 10                	jmp    10127a <kbd_proc_data+0x14f>
			c += 'A' - 'a';
		else if ('A' <= c && c <= 'Z')
  10126a:	83 7d e8 40          	cmpl   $0x40,-0x18(%ebp)
  10126e:	7e 0a                	jle    10127a <kbd_proc_data+0x14f>
  101270:	83 7d e8 5a          	cmpl   $0x5a,-0x18(%ebp)
  101274:	7f 04                	jg     10127a <kbd_proc_data+0x14f>
			c += 'a' - 'A';
  101276:	83 45 e8 20          	addl   $0x20,-0x18(%ebp)
	}

	// Process special keys
	// Ctrl-Alt-Del: reboot
	if (!(~shift & (CTL | ALT)) && c == KEY_DEL) {
  10127a:	a1 28 e0 10 00       	mov    0x10e028,%eax
  10127f:	f7 d0                	not    %eax
  101281:	83 e0 06             	and    $0x6,%eax
  101284:	85 c0                	test   %eax,%eax
  101286:	75 28                	jne    1012b0 <kbd_proc_data+0x185>
  101288:	81 7d e8 e9 00 00 00 	cmpl   $0xe9,-0x18(%ebp)
  10128f:	75 1f                	jne    1012b0 <kbd_proc_data+0x185>
		cprintf("Rebooting!\n");
  101291:	c7 04 24 2d 33 10 00 	movl   $0x10332d,(%esp)
  101298:	e8 d3 ee ff ff       	call   100170 <cprintf>
  10129d:	66 c7 45 f6 92 00    	movw   $0x92,-0xa(%ebp)
  1012a3:	c6 45 f5 03          	movb   $0x3,-0xb(%ebp)
			: "memory", "cc");
}

static inline void
outb(uint16_t port, uint8_t data) {
	asm volatile ("outb %0, %1" :: "a" (data), "d" (port));
  1012a7:	0f b6 45 f5          	movzbl -0xb(%ebp),%eax
  1012ab:	0f b7 55 f6          	movzwl -0xa(%ebp),%edx
  1012af:	ee                   	out    %al,(%dx)
		outb(0x92, 0x3); // courtesy of Chris Frost
	}
	return c;
  1012b0:	8b 45 e8             	mov    -0x18(%ebp),%eax
}
  1012b3:	c9                   	leave  
  1012b4:	c3                   	ret    

001012b5 <kbd_intr>:

/* kbd_intr - try to feed input characters from keyboard */
static void
kbd_intr(void) {
  1012b5:	55                   	push   %ebp
  1012b6:	89 e5                	mov    %esp,%ebp
  1012b8:	83 ec 18             	sub    $0x18,%esp
	cons_intr(kbd_proc_data);
  1012bb:	c7 04 24 2b 11 10 00 	movl   $0x10112b,(%esp)
  1012c2:	e8 a6 fd ff ff       	call   10106d <cons_intr>
}
  1012c7:	c9                   	leave  
  1012c8:	c3                   	ret    

001012c9 <kbd_init>:

static void
kbd_init(void) {
  1012c9:	55                   	push   %ebp
  1012ca:	89 e5                	mov    %esp,%ebp
  1012cc:	83 ec 18             	sub    $0x18,%esp
	// drain the kbd buffer
	kbd_intr();
  1012cf:	e8 e1 ff ff ff       	call   1012b5 <kbd_intr>
	pic_enable(IRQ_KBD);
  1012d4:	c7 04 24 01 00 00 00 	movl   $0x1,(%esp)
  1012db:	e8 0c 01 00 00       	call   1013ec <pic_enable>
}
  1012e0:	c9                   	leave  
  1012e1:	c3                   	ret    

001012e2 <cons_init>:

/* cons_init - initializes the console devices */
void
cons_init(void) {
  1012e2:	55                   	push   %ebp
  1012e3:	89 e5                	mov    %esp,%ebp
  1012e5:	83 ec 18             	sub    $0x18,%esp
	cga_init();
  1012e8:	e8 8b f8 ff ff       	call   100b78 <cga_init>
	serial_init();
  1012ed:	e8 6c f9 ff ff       	call   100c5e <serial_init>
	kbd_init();
  1012f2:	e8 d2 ff ff ff       	call   1012c9 <kbd_init>
	if (!serial_exists) {
  1012f7:	a1 08 de 10 00       	mov    0x10de08,%eax
  1012fc:	85 c0                	test   %eax,%eax
  1012fe:	75 0c                	jne    10130c <cons_init+0x2a>
		cprintf("serial port does not exist!!\n");
  101300:	c7 04 24 39 33 10 00 	movl   $0x103339,(%esp)
  101307:	e8 64 ee ff ff       	call   100170 <cprintf>
	}
}
  10130c:	c9                   	leave  
  10130d:	c3                   	ret    

0010130e <cons_putc>:

/* cons_putc - print a single character @c to console devices */
void
cons_putc(int c) {
  10130e:	55                   	push   %ebp
  10130f:	89 e5                	mov    %esp,%ebp
  101311:	83 ec 18             	sub    $0x18,%esp
	lpt_putc(c);
  101314:	8b 45 08             	mov    0x8(%ebp),%eax
  101317:	89 04 24             	mov    %eax,(%esp)
  10131a:	e8 9b fa ff ff       	call   100dba <lpt_putc>
	cga_putc(c);
  10131f:	8b 45 08             	mov    0x8(%ebp),%eax
  101322:	89 04 24             	mov    %eax,(%esp)
  101325:	e8 cf fa ff ff       	call   100df9 <cga_putc>
	serial_putc(c);
  10132a:	8b 45 08             	mov    0x8(%ebp),%eax
  10132d:	89 04 24             	mov    %eax,(%esp)
  101330:	e8 f9 fc ff ff       	call   10102e <serial_putc>
}
  101335:	c9                   	leave  
  101336:	c3                   	ret    

00101337 <cons_getc>:
/* *
 * cons_getc - return the next input character from console,
 * or 0 if none waiting.
 * */
int
cons_getc(void) {
  101337:	55                   	push   %ebp
  101338:	89 e5                	mov    %esp,%ebp
  10133a:	83 ec 18             	sub    $0x18,%esp
	int c;

	// poll for any pending input characters,
	// so that this function works even when interrupts are disabled
	// (e.g., when called from the kernel monitor).
	serial_intr();
  10133d:	e8 cc fd ff ff       	call   10110e <serial_intr>
	kbd_intr();
  101342:	e8 6e ff ff ff       	call   1012b5 <kbd_intr>

	// grab the next character from the input buffer.
	if (cons.rpos != cons.wpos) {
  101347:	8b 15 20 e0 10 00    	mov    0x10e020,%edx
  10134d:	a1 24 e0 10 00       	mov    0x10e024,%eax
  101352:	39 c2                	cmp    %eax,%edx
  101354:	74 35                	je     10138b <cons_getc+0x54>
		c = cons.buf[cons.rpos ++];
  101356:	a1 20 e0 10 00       	mov    0x10e020,%eax
  10135b:	0f b6 90 20 de 10 00 	movzbl 0x10de20(%eax),%edx
  101362:	0f b6 d2             	movzbl %dl,%edx
  101365:	89 55 f4             	mov    %edx,-0xc(%ebp)
  101368:	83 c0 01             	add    $0x1,%eax
  10136b:	a3 20 e0 10 00       	mov    %eax,0x10e020
		if (cons.rpos == CONSBUFSIZE) {
  101370:	a1 20 e0 10 00       	mov    0x10e020,%eax
  101375:	3d 00 02 00 00       	cmp    $0x200,%eax
  10137a:	75 0a                	jne    101386 <cons_getc+0x4f>
			cons.rpos = 0;
  10137c:	c7 05 20 e0 10 00 00 	movl   $0x0,0x10e020
  101383:	00 00 00 
		}
		return c;
  101386:	8b 45 f4             	mov    -0xc(%ebp),%eax
  101389:	eb 05                	jmp    101390 <cons_getc+0x59>
	}
	return 0;
  10138b:	b8 00 00 00 00       	mov    $0x0,%eax
}
  101390:	c9                   	leave  
  101391:	c3                   	ret    
	...

00101394 <pic_setmask>:
// Initial IRQ mask has interrupt 2 enabled (for slave 8259A).
static uint16_t irq_mask = 0xFFFF & ~(1 << IRQ_SLAVE);
static bool did_init = 0;

static void
pic_setmask(uint16_t mask) {
  101394:	55                   	push   %ebp
  101395:	89 e5                	mov    %esp,%ebp
  101397:	83 ec 14             	sub    $0x14,%esp
  10139a:	8b 45 08             	mov    0x8(%ebp),%eax
  10139d:	66 89 45 ec          	mov    %ax,-0x14(%ebp)
	irq_mask = mask;
  1013a1:	0f b7 45 ec          	movzwl -0x14(%ebp),%eax
  1013a5:	66 a3 50 d5 10 00    	mov    %ax,0x10d550
	if (did_init) {
  1013ab:	a1 2c e0 10 00       	mov    0x10e02c,%eax
  1013b0:	85 c0                	test   %eax,%eax
  1013b2:	74 36                	je     1013ea <pic_setmask+0x56>
		outb(IO_PIC1 + 1, mask);
  1013b4:	0f b7 45 ec          	movzwl -0x14(%ebp),%eax
  1013b8:	0f b6 c0             	movzbl %al,%eax
  1013bb:	66 c7 45 fa 21 00    	movw   $0x21,-0x6(%ebp)
  1013c1:	88 45 f9             	mov    %al,-0x7(%ebp)
  1013c4:	0f b6 45 f9          	movzbl -0x7(%ebp),%eax
  1013c8:	0f b7 55 fa          	movzwl -0x6(%ebp),%edx
  1013cc:	ee                   	out    %al,(%dx)
		outb(IO_PIC2 + 1, mask >> 8);
  1013cd:	0f b7 45 ec          	movzwl -0x14(%ebp),%eax
  1013d1:	66 c1 e8 08          	shr    $0x8,%ax
  1013d5:	0f b6 c0             	movzbl %al,%eax
  1013d8:	66 c7 45 fe a1 00    	movw   $0xa1,-0x2(%ebp)
  1013de:	88 45 fd             	mov    %al,-0x3(%ebp)
  1013e1:	0f b6 45 fd          	movzbl -0x3(%ebp),%eax
  1013e5:	0f b7 55 fe          	movzwl -0x2(%ebp),%edx
  1013e9:	ee                   	out    %al,(%dx)
	}
}
  1013ea:	c9                   	leave  
  1013eb:	c3                   	ret    

001013ec <pic_enable>:

void
pic_enable(unsigned int irq) {
  1013ec:	55                   	push   %ebp
  1013ed:	89 e5                	mov    %esp,%ebp
  1013ef:	53                   	push   %ebx
  1013f0:	83 ec 04             	sub    $0x4,%esp
	pic_setmask(irq_mask & ~(1 << irq));
  1013f3:	8b 45 08             	mov    0x8(%ebp),%eax
  1013f6:	ba 01 00 00 00       	mov    $0x1,%edx
  1013fb:	89 d3                	mov    %edx,%ebx
  1013fd:	89 c1                	mov    %eax,%ecx
  1013ff:	d3 e3                	shl    %cl,%ebx
  101401:	89 d8                	mov    %ebx,%eax
  101403:	89 c2                	mov    %eax,%edx
  101405:	f7 d2                	not    %edx
  101407:	0f b7 05 50 d5 10 00 	movzwl 0x10d550,%eax
  10140e:	21 d0                	and    %edx,%eax
  101410:	0f b7 c0             	movzwl %ax,%eax
  101413:	89 04 24             	mov    %eax,(%esp)
  101416:	e8 79 ff ff ff       	call   101394 <pic_setmask>
}
  10141b:	83 c4 04             	add    $0x4,%esp
  10141e:	5b                   	pop    %ebx
  10141f:	5d                   	pop    %ebp
  101420:	c3                   	ret    

00101421 <pic_init>:

/* pic_init - initialize the 8259A interrupt controllers */
void
pic_init(void) {
  101421:	55                   	push   %ebp
  101422:	89 e5                	mov    %esp,%ebp
  101424:	83 ec 44             	sub    $0x44,%esp
	did_init = 1;
  101427:	c7 05 2c e0 10 00 01 	movl   $0x1,0x10e02c
  10142e:	00 00 00 
  101431:	66 c7 45 ca 21 00    	movw   $0x21,-0x36(%ebp)
  101437:	c6 45 c9 ff          	movb   $0xff,-0x37(%ebp)
  10143b:	0f b6 45 c9          	movzbl -0x37(%ebp),%eax
  10143f:	0f b7 55 ca          	movzwl -0x36(%ebp),%edx
  101443:	ee                   	out    %al,(%dx)
  101444:	66 c7 45 ce a1 00    	movw   $0xa1,-0x32(%ebp)
  10144a:	c6 45 cd ff          	movb   $0xff,-0x33(%ebp)
  10144e:	0f b6 45 cd          	movzbl -0x33(%ebp),%eax
  101452:	0f b7 55 ce          	movzwl -0x32(%ebp),%edx
  101456:	ee                   	out    %al,(%dx)
  101457:	66 c7 45 d2 20 00    	movw   $0x20,-0x2e(%ebp)
  10145d:	c6 45 d1 11          	movb   $0x11,-0x2f(%ebp)
  101461:	0f b6 45 d1          	movzbl -0x2f(%ebp),%eax
  101465:	0f b7 55 d2          	movzwl -0x2e(%ebp),%edx
  101469:	ee                   	out    %al,(%dx)
  10146a:	66 c7 45 d6 21 00    	movw   $0x21,-0x2a(%ebp)
  101470:	c6 45 d5 20          	movb   $0x20,-0x2b(%ebp)
  101474:	0f b6 45 d5          	movzbl -0x2b(%ebp),%eax
  101478:	0f b7 55 d6          	movzwl -0x2a(%ebp),%edx
  10147c:	ee                   	out    %al,(%dx)
  10147d:	66 c7 45 da 21 00    	movw   $0x21,-0x26(%ebp)
  101483:	c6 45 d9 04          	movb   $0x4,-0x27(%ebp)
  101487:	0f b6 45 d9          	movzbl -0x27(%ebp),%eax
  10148b:	0f b7 55 da          	movzwl -0x26(%ebp),%edx
  10148f:	ee                   	out    %al,(%dx)
  101490:	66 c7 45 de 21 00    	movw   $0x21,-0x22(%ebp)
  101496:	c6 45 dd 03          	movb   $0x3,-0x23(%ebp)
  10149a:	0f b6 45 dd          	movzbl -0x23(%ebp),%eax
  10149e:	0f b7 55 de          	movzwl -0x22(%ebp),%edx
  1014a2:	ee                   	out    %al,(%dx)
  1014a3:	66 c7 45 e2 a0 00    	movw   $0xa0,-0x1e(%ebp)
  1014a9:	c6 45 e1 11          	movb   $0x11,-0x1f(%ebp)
  1014ad:	0f b6 45 e1          	movzbl -0x1f(%ebp),%eax
  1014b1:	0f b7 55 e2          	movzwl -0x1e(%ebp),%edx
  1014b5:	ee                   	out    %al,(%dx)
  1014b6:	66 c7 45 e6 a1 00    	movw   $0xa1,-0x1a(%ebp)
  1014bc:	c6 45 e5 28          	movb   $0x28,-0x1b(%ebp)
  1014c0:	0f b6 45 e5          	movzbl -0x1b(%ebp),%eax
  1014c4:	0f b7 55 e6          	movzwl -0x1a(%ebp),%edx
  1014c8:	ee                   	out    %al,(%dx)
  1014c9:	66 c7 45 ea a1 00    	movw   $0xa1,-0x16(%ebp)
  1014cf:	c6 45 e9 02          	movb   $0x2,-0x17(%ebp)
  1014d3:	0f b6 45 e9          	movzbl -0x17(%ebp),%eax
  1014d7:	0f b7 55 ea          	movzwl -0x16(%ebp),%edx
  1014db:	ee                   	out    %al,(%dx)
  1014dc:	66 c7 45 ee a1 00    	movw   $0xa1,-0x12(%ebp)
  1014e2:	c6 45 ed 03          	movb   $0x3,-0x13(%ebp)
  1014e6:	0f b6 45 ed          	movzbl -0x13(%ebp),%eax
  1014ea:	0f b7 55 ee          	movzwl -0x12(%ebp),%edx
  1014ee:	ee                   	out    %al,(%dx)
  1014ef:	66 c7 45 f2 20 00    	movw   $0x20,-0xe(%ebp)
  1014f5:	c6 45 f1 68          	movb   $0x68,-0xf(%ebp)
  1014f9:	0f b6 45 f1          	movzbl -0xf(%ebp),%eax
  1014fd:	0f b7 55 f2          	movzwl -0xe(%ebp),%edx
  101501:	ee                   	out    %al,(%dx)
  101502:	66 c7 45 f6 20 00    	movw   $0x20,-0xa(%ebp)
  101508:	c6 45 f5 0a          	movb   $0xa,-0xb(%ebp)
  10150c:	0f b6 45 f5          	movzbl -0xb(%ebp),%eax
  101510:	0f b7 55 f6          	movzwl -0xa(%ebp),%edx
  101514:	ee                   	out    %al,(%dx)
  101515:	66 c7 45 fa a0 00    	movw   $0xa0,-0x6(%ebp)
  10151b:	c6 45 f9 68          	movb   $0x68,-0x7(%ebp)
  10151f:	0f b6 45 f9          	movzbl -0x7(%ebp),%eax
  101523:	0f b7 55 fa          	movzwl -0x6(%ebp),%edx
  101527:	ee                   	out    %al,(%dx)
  101528:	66 c7 45 fe a0 00    	movw   $0xa0,-0x2(%ebp)
  10152e:	c6 45 fd 0a          	movb   $0xa,-0x3(%ebp)
  101532:	0f b6 45 fd          	movzbl -0x3(%ebp),%eax
  101536:	0f b7 55 fe          	movzwl -0x2(%ebp),%edx
  10153a:	ee                   	out    %al,(%dx)
	outb(IO_PIC1, 0x0a);	// read IRR by default

	outb(IO_PIC2, 0x68);	// OCW3
	outb(IO_PIC2, 0x0a);	// OCW3

	if (irq_mask != 0xFFFF) {
  10153b:	0f b7 05 50 d5 10 00 	movzwl 0x10d550,%eax
  101542:	66 83 f8 ff          	cmp    $0xffffffff,%ax
  101546:	74 12                	je     10155a <pic_init+0x139>
		pic_setmask(irq_mask);
  101548:	0f b7 05 50 d5 10 00 	movzwl 0x10d550,%eax
  10154f:	0f b7 c0             	movzwl %ax,%eax
  101552:	89 04 24             	mov    %eax,(%esp)
  101555:	e8 3a fe ff ff       	call   101394 <pic_setmask>
	}
}
  10155a:	c9                   	leave  
  10155b:	c3                   	ret    

0010155c <print_ticks>:
#include <assert.h>

#define TICK_NUM 100
static int time_trap_Num = 0;
static void print_ticks() 
{
  10155c:	55                   	push   %ebp
  10155d:	89 e5                	mov    %esp,%ebp
  10155f:	83 ec 18             	sub    $0x18,%esp
	cprintf("%d ticks\n",TICK_NUM);
  101562:	c7 44 24 04 64 00 00 	movl   $0x64,0x4(%esp)
  101569:	00 
  10156a:	c7 04 24 60 33 10 00 	movl   $0x103360,(%esp)
  101571:	e8 fa eb ff ff       	call   100170 <cprintf>
	#ifdef DEBUG_GRADE
		cprintf("End of Test.\n");
  101576:	c7 04 24 6a 33 10 00 	movl   $0x10336a,(%esp)
  10157d:	e8 ee eb ff ff       	call   100170 <cprintf>
		panic("EOT: kernel seems ok.");
  101582:	c7 44 24 08 78 33 10 	movl   $0x103378,0x8(%esp)
  101589:	00 
  10158a:	c7 44 24 04 12 00 00 	movl   $0x12,0x4(%esp)
  101591:	00 
  101592:	c7 04 24 8e 33 10 00 	movl   $0x10338e,(%esp)
  101599:	e8 6e f4 ff ff       	call   100a0c <__panic>

0010159e <idt_init>:

static struct pseudodesc idt_pd = { sizeof(idt) - 1, (uint32_t)idt };

/* idt_init - initialize IDT to each of the entry points in kern/trap/vectors.S */
void idt_init(void) 
{
  10159e:	55                   	push   %ebp
  10159f:	89 e5                	mov    %esp,%ebp
  1015a1:	83 ec 10             	sub    $0x10,%esp
	/* LAB1 YOUR CODE */
	extern uintptr_t __vectors[];
	int i;
	for (i = 0; i < sizeof(idt)/sizeof(struct gatedesc);i++) 
  1015a4:	c7 45 f8 00 00 00 00 	movl   $0x0,-0x8(%ebp)
  1015ab:	e9 bc 00 00 00       	jmp    10166c <idt_init+0xce>
	{
		SETGATE(idt[i], 1, GD_KTEXT, __vectors[i], DPL_KERNEL);
  1015b0:	8b 45 f8             	mov    -0x8(%ebp),%eax
  1015b3:	8b 55 f8             	mov    -0x8(%ebp),%edx
  1015b6:	8b 14 95 e0 d5 10 00 	mov    0x10d5e0(,%edx,4),%edx
  1015bd:	66 89 14 c5 60 e0 10 	mov    %dx,0x10e060(,%eax,8)
  1015c4:	00 
  1015c5:	8b 45 f8             	mov    -0x8(%ebp),%eax
  1015c8:	66 c7 04 c5 62 e0 10 	movw   $0x8,0x10e062(,%eax,8)
  1015cf:	00 08 00 
  1015d2:	8b 45 f8             	mov    -0x8(%ebp),%eax
  1015d5:	0f b6 14 c5 64 e0 10 	movzbl 0x10e064(,%eax,8),%edx
  1015dc:	00 
  1015dd:	83 e2 e0             	and    $0xffffffe0,%edx
  1015e0:	88 14 c5 64 e0 10 00 	mov    %dl,0x10e064(,%eax,8)
  1015e7:	8b 45 f8             	mov    -0x8(%ebp),%eax
  1015ea:	0f b6 14 c5 64 e0 10 	movzbl 0x10e064(,%eax,8),%edx
  1015f1:	00 
  1015f2:	83 e2 1f             	and    $0x1f,%edx
  1015f5:	88 14 c5 64 e0 10 00 	mov    %dl,0x10e064(,%eax,8)
  1015fc:	8b 45 f8             	mov    -0x8(%ebp),%eax
  1015ff:	0f b6 14 c5 65 e0 10 	movzbl 0x10e065(,%eax,8),%edx
  101606:	00 
  101607:	83 ca 0f             	or     $0xf,%edx
  10160a:	88 14 c5 65 e0 10 00 	mov    %dl,0x10e065(,%eax,8)
  101611:	8b 45 f8             	mov    -0x8(%ebp),%eax
  101614:	0f b6 14 c5 65 e0 10 	movzbl 0x10e065(,%eax,8),%edx
  10161b:	00 
  10161c:	83 e2 ef             	and    $0xffffffef,%edx
  10161f:	88 14 c5 65 e0 10 00 	mov    %dl,0x10e065(,%eax,8)
  101626:	8b 45 f8             	mov    -0x8(%ebp),%eax
  101629:	0f b6 14 c5 65 e0 10 	movzbl 0x10e065(,%eax,8),%edx
  101630:	00 
  101631:	83 e2 9f             	and    $0xffffff9f,%edx
  101634:	88 14 c5 65 e0 10 00 	mov    %dl,0x10e065(,%eax,8)
  10163b:	8b 45 f8             	mov    -0x8(%ebp),%eax
  10163e:	0f b6 14 c5 65 e0 10 	movzbl 0x10e065(,%eax,8),%edx
  101645:	00 
  101646:	83 ca 80             	or     $0xffffff80,%edx
  101649:	88 14 c5 65 e0 10 00 	mov    %dl,0x10e065(,%eax,8)
  101650:	8b 45 f8             	mov    -0x8(%ebp),%eax
  101653:	8b 55 f8             	mov    -0x8(%ebp),%edx
  101656:	8b 14 95 e0 d5 10 00 	mov    0x10d5e0(,%edx,4),%edx
  10165d:	c1 ea 10             	shr    $0x10,%edx
  101660:	66 89 14 c5 66 e0 10 	mov    %dx,0x10e066(,%eax,8)
  101667:	00 
void idt_init(void) 
{
	/* LAB1 YOUR CODE */
	extern uintptr_t __vectors[];
	int i;
	for (i = 0; i < sizeof(idt)/sizeof(struct gatedesc);i++) 
  101668:	83 45 f8 01          	addl   $0x1,-0x8(%ebp)
  10166c:	8b 45 f8             	mov    -0x8(%ebp),%eax
  10166f:	3d ff 00 00 00       	cmp    $0xff,%eax
  101674:	0f 86 36 ff ff ff    	jbe    1015b0 <idt_init+0x12>
	{
		SETGATE(idt[i], 1, GD_KTEXT, __vectors[i], DPL_KERNEL);
	}
	SETGATE(idt[T_SYSCALL], 1, GD_KTEXT, __vectors[T_SYSCALL], DPL_USER);
  10167a:	a1 e0 d7 10 00       	mov    0x10d7e0,%eax
  10167f:	66 a3 60 e4 10 00    	mov    %ax,0x10e460
  101685:	66 c7 05 62 e4 10 00 	movw   $0x8,0x10e462
  10168c:	08 00 
  10168e:	0f b6 05 64 e4 10 00 	movzbl 0x10e464,%eax
  101695:	83 e0 e0             	and    $0xffffffe0,%eax
  101698:	a2 64 e4 10 00       	mov    %al,0x10e464
  10169d:	0f b6 05 64 e4 10 00 	movzbl 0x10e464,%eax
  1016a4:	83 e0 1f             	and    $0x1f,%eax
  1016a7:	a2 64 e4 10 00       	mov    %al,0x10e464
  1016ac:	0f b6 05 65 e4 10 00 	movzbl 0x10e465,%eax
  1016b3:	83 c8 0f             	or     $0xf,%eax
  1016b6:	a2 65 e4 10 00       	mov    %al,0x10e465
  1016bb:	0f b6 05 65 e4 10 00 	movzbl 0x10e465,%eax
  1016c2:	83 e0 ef             	and    $0xffffffef,%eax
  1016c5:	a2 65 e4 10 00       	mov    %al,0x10e465
  1016ca:	0f b6 05 65 e4 10 00 	movzbl 0x10e465,%eax
  1016d1:	83 c8 60             	or     $0x60,%eax
  1016d4:	a2 65 e4 10 00       	mov    %al,0x10e465
  1016d9:	0f b6 05 65 e4 10 00 	movzbl 0x10e465,%eax
  1016e0:	83 c8 80             	or     $0xffffff80,%eax
  1016e3:	a2 65 e4 10 00       	mov    %al,0x10e465
  1016e8:	a1 e0 d7 10 00       	mov    0x10d7e0,%eax
  1016ed:	c1 e8 10             	shr    $0x10,%eax
  1016f0:	66 a3 66 e4 10 00    	mov    %ax,0x10e466
  1016f6:	c7 45 fc 60 d5 10 00 	movl   $0x10d560,-0x4(%ebp)
	return ebp;
}

static inline void
lidt(struct pseudodesc *pd) {
	asm volatile ("lidt (%0)" :: "r" (pd));
  1016fd:	8b 45 fc             	mov    -0x4(%ebp),%eax
  101700:	0f 01 18             	lidtl  (%eax)
	lidt(&idt_pd);
}
  101703:	c9                   	leave  
  101704:	c3                   	ret    

00101705 <trapname>:

static const char * trapname(int trapno) 
{
  101705:	55                   	push   %ebp
  101706:	89 e5                	mov    %esp,%ebp
		"Alignment Check",
		"Machine-Check",
		"SIMD Floating-Point Exception"
	};

	if (trapno < sizeof(excnames)/sizeof(const char * const)) {
  101708:	8b 45 08             	mov    0x8(%ebp),%eax
  10170b:	83 f8 13             	cmp    $0x13,%eax
  10170e:	77 0c                	ja     10171c <trapname+0x17>
		return excnames[trapno];
  101710:	8b 45 08             	mov    0x8(%ebp),%eax
  101713:	8b 04 85 c0 36 10 00 	mov    0x1036c0(,%eax,4),%eax
  10171a:	eb 18                	jmp    101734 <trapname+0x2f>
	}
	if (trapno >= IRQ_OFFSET && trapno < IRQ_OFFSET + 16) {
  10171c:	83 7d 08 1f          	cmpl   $0x1f,0x8(%ebp)
  101720:	7e 0d                	jle    10172f <trapname+0x2a>
  101722:	83 7d 08 2f          	cmpl   $0x2f,0x8(%ebp)
  101726:	7f 07                	jg     10172f <trapname+0x2a>
		return "Hardware Interrupt";
  101728:	b8 9f 33 10 00       	mov    $0x10339f,%eax
  10172d:	eb 05                	jmp    101734 <trapname+0x2f>
	}
	return "(unknown trap)";
  10172f:	b8 b2 33 10 00       	mov    $0x1033b2,%eax
}
  101734:	5d                   	pop    %ebp
  101735:	c3                   	ret    

00101736 <trap_in_kernel>:

/* trap_in_kernel - test if trap happened in kernel */
bool
trap_in_kernel(struct trapframe *tf) {
  101736:	55                   	push   %ebp
  101737:	89 e5                	mov    %esp,%ebp
	return (tf->tf_cs == (uint16_t)KERNEL_CS);
  101739:	8b 45 08             	mov    0x8(%ebp),%eax
  10173c:	0f b7 40 34          	movzwl 0x34(%eax),%eax
  101740:	66 83 f8 08          	cmp    $0x8,%ax
  101744:	0f 94 c0             	sete   %al
  101747:	0f b6 c0             	movzbl %al,%eax
}
  10174a:	5d                   	pop    %ebp
  10174b:	c3                   	ret    

0010174c <print_trapframe>:
	"TF", "IF", "DF", "OF", NULL, NULL, "NT", NULL,
	"RF", "VM", "AC", "VIF", "VIP", "ID", NULL, NULL,
};

void
print_trapframe(struct trapframe *tf) {
  10174c:	55                   	push   %ebp
  10174d:	89 e5                	mov    %esp,%ebp
  10174f:	83 ec 28             	sub    $0x28,%esp
	cprintf("trapframe at %p\n", tf);
  101752:	8b 45 08             	mov    0x8(%ebp),%eax
  101755:	89 44 24 04          	mov    %eax,0x4(%esp)
  101759:	c7 04 24 f3 33 10 00 	movl   $0x1033f3,(%esp)
  101760:	e8 0b ea ff ff       	call   100170 <cprintf>
	print_regs(&tf->tf_regs);
  101765:	8b 45 08             	mov    0x8(%ebp),%eax
  101768:	89 04 24             	mov    %eax,(%esp)
  10176b:	e8 6d 01 00 00       	call   1018dd <print_regs>
	cprintf("  es   0x----%04x\n", tf->tf_es);
  101770:	8b 45 08             	mov    0x8(%ebp),%eax
  101773:	0f b7 40 20          	movzwl 0x20(%eax),%eax
  101777:	0f b7 c0             	movzwl %ax,%eax
  10177a:	89 44 24 04          	mov    %eax,0x4(%esp)
  10177e:	c7 04 24 04 34 10 00 	movl   $0x103404,(%esp)
  101785:	e8 e6 e9 ff ff       	call   100170 <cprintf>
	cprintf("  ds   0x----%04x\n", tf->tf_ds);
  10178a:	8b 45 08             	mov    0x8(%ebp),%eax
  10178d:	0f b7 40 24          	movzwl 0x24(%eax),%eax
  101791:	0f b7 c0             	movzwl %ax,%eax
  101794:	89 44 24 04          	mov    %eax,0x4(%esp)
  101798:	c7 04 24 17 34 10 00 	movl   $0x103417,(%esp)
  10179f:	e8 cc e9 ff ff       	call   100170 <cprintf>
	cprintf("  trap 0x%08x %s\n", tf->tf_trapno, trapname(tf->tf_trapno));
  1017a4:	8b 45 08             	mov    0x8(%ebp),%eax
  1017a7:	8b 40 28             	mov    0x28(%eax),%eax
  1017aa:	89 04 24             	mov    %eax,(%esp)
  1017ad:	e8 53 ff ff ff       	call   101705 <trapname>
  1017b2:	8b 55 08             	mov    0x8(%ebp),%edx
  1017b5:	8b 52 28             	mov    0x28(%edx),%edx
  1017b8:	89 44 24 08          	mov    %eax,0x8(%esp)
  1017bc:	89 54 24 04          	mov    %edx,0x4(%esp)
  1017c0:	c7 04 24 2a 34 10 00 	movl   $0x10342a,(%esp)
  1017c7:	e8 a4 e9 ff ff       	call   100170 <cprintf>
	cprintf("  err  0x%08x\n", tf->tf_err);
  1017cc:	8b 45 08             	mov    0x8(%ebp),%eax
  1017cf:	8b 40 2c             	mov    0x2c(%eax),%eax
  1017d2:	89 44 24 04          	mov    %eax,0x4(%esp)
  1017d6:	c7 04 24 3c 34 10 00 	movl   $0x10343c,(%esp)
  1017dd:	e8 8e e9 ff ff       	call   100170 <cprintf>
	cprintf("  eip  0x%08x\n", tf->tf_eip);
  1017e2:	8b 45 08             	mov    0x8(%ebp),%eax
  1017e5:	8b 40 30             	mov    0x30(%eax),%eax
  1017e8:	89 44 24 04          	mov    %eax,0x4(%esp)
  1017ec:	c7 04 24 4b 34 10 00 	movl   $0x10344b,(%esp)
  1017f3:	e8 78 e9 ff ff       	call   100170 <cprintf>
	cprintf("  cs   0x----%04x\n", tf->tf_cs);
  1017f8:	8b 45 08             	mov    0x8(%ebp),%eax
  1017fb:	0f b7 40 34          	movzwl 0x34(%eax),%eax
  1017ff:	0f b7 c0             	movzwl %ax,%eax
  101802:	89 44 24 04          	mov    %eax,0x4(%esp)
  101806:	c7 04 24 5a 34 10 00 	movl   $0x10345a,(%esp)
  10180d:	e8 5e e9 ff ff       	call   100170 <cprintf>
	cprintf("  flag 0x%08x ", tf->tf_eflags);
  101812:	8b 45 08             	mov    0x8(%ebp),%eax
  101815:	8b 40 38             	mov    0x38(%eax),%eax
  101818:	89 44 24 04          	mov    %eax,0x4(%esp)
  10181c:	c7 04 24 6d 34 10 00 	movl   $0x10346d,(%esp)
  101823:	e8 48 e9 ff ff       	call   100170 <cprintf>

	int i, j;
	for (i = 0, j = 1; i < sizeof(IA32flags) / sizeof(IA32flags[0]); i ++, j <<= 1) {
  101828:	c7 45 f0 00 00 00 00 	movl   $0x0,-0x10(%ebp)
  10182f:	c7 45 f4 01 00 00 00 	movl   $0x1,-0xc(%ebp)
  101836:	eb 3e                	jmp    101876 <print_trapframe+0x12a>
		if ((tf->tf_eflags & j) && IA32flags[i] != NULL) {
  101838:	8b 45 08             	mov    0x8(%ebp),%eax
  10183b:	8b 50 38             	mov    0x38(%eax),%edx
  10183e:	8b 45 f4             	mov    -0xc(%ebp),%eax
  101841:	21 d0                	and    %edx,%eax
  101843:	85 c0                	test   %eax,%eax
  101845:	74 28                	je     10186f <print_trapframe+0x123>
  101847:	8b 45 f0             	mov    -0x10(%ebp),%eax
  10184a:	8b 04 85 80 d5 10 00 	mov    0x10d580(,%eax,4),%eax
  101851:	85 c0                	test   %eax,%eax
  101853:	74 1a                	je     10186f <print_trapframe+0x123>
			cprintf("%s,", IA32flags[i]);
  101855:	8b 45 f0             	mov    -0x10(%ebp),%eax
  101858:	8b 04 85 80 d5 10 00 	mov    0x10d580(,%eax,4),%eax
  10185f:	89 44 24 04          	mov    %eax,0x4(%esp)
  101863:	c7 04 24 7c 34 10 00 	movl   $0x10347c,(%esp)
  10186a:	e8 01 e9 ff ff       	call   100170 <cprintf>
	cprintf("  eip  0x%08x\n", tf->tf_eip);
	cprintf("  cs   0x----%04x\n", tf->tf_cs);
	cprintf("  flag 0x%08x ", tf->tf_eflags);

	int i, j;
	for (i = 0, j = 1; i < sizeof(IA32flags) / sizeof(IA32flags[0]); i ++, j <<= 1) {
  10186f:	83 45 f0 01          	addl   $0x1,-0x10(%ebp)
  101873:	d1 65 f4             	shll   -0xc(%ebp)
  101876:	8b 45 f0             	mov    -0x10(%ebp),%eax
  101879:	83 f8 17             	cmp    $0x17,%eax
  10187c:	76 ba                	jbe    101838 <print_trapframe+0xec>
		if ((tf->tf_eflags & j) && IA32flags[i] != NULL) {
			cprintf("%s,", IA32flags[i]);
		}
	}
	cprintf("IOPL=%d\n", (tf->tf_eflags & FL_IOPL_MASK) >> 12);
  10187e:	8b 45 08             	mov    0x8(%ebp),%eax
  101881:	8b 40 38             	mov    0x38(%eax),%eax
  101884:	25 00 30 00 00       	and    $0x3000,%eax
  101889:	c1 e8 0c             	shr    $0xc,%eax
  10188c:	89 44 24 04          	mov    %eax,0x4(%esp)
  101890:	c7 04 24 80 34 10 00 	movl   $0x103480,(%esp)
  101897:	e8 d4 e8 ff ff       	call   100170 <cprintf>

	if (!trap_in_kernel(tf)) {
  10189c:	8b 45 08             	mov    0x8(%ebp),%eax
  10189f:	89 04 24             	mov    %eax,(%esp)
  1018a2:	e8 8f fe ff ff       	call   101736 <trap_in_kernel>
  1018a7:	85 c0                	test   %eax,%eax
  1018a9:	75 30                	jne    1018db <print_trapframe+0x18f>
		cprintf("  esp  0x%08x\n", tf->tf_esp);
  1018ab:	8b 45 08             	mov    0x8(%ebp),%eax
  1018ae:	8b 40 3c             	mov    0x3c(%eax),%eax
  1018b1:	89 44 24 04          	mov    %eax,0x4(%esp)
  1018b5:	c7 04 24 89 34 10 00 	movl   $0x103489,(%esp)
  1018bc:	e8 af e8 ff ff       	call   100170 <cprintf>
		cprintf("  ss   0x----%04x\n", tf->tf_ss);
  1018c1:	8b 45 08             	mov    0x8(%ebp),%eax
  1018c4:	0f b7 40 40          	movzwl 0x40(%eax),%eax
  1018c8:	0f b7 c0             	movzwl %ax,%eax
  1018cb:	89 44 24 04          	mov    %eax,0x4(%esp)
  1018cf:	c7 04 24 98 34 10 00 	movl   $0x103498,(%esp)
  1018d6:	e8 95 e8 ff ff       	call   100170 <cprintf>
	}
}
  1018db:	c9                   	leave  
  1018dc:	c3                   	ret    

001018dd <print_regs>:

void
print_regs(struct pushregs *regs) {
  1018dd:	55                   	push   %ebp
  1018de:	89 e5                	mov    %esp,%ebp
  1018e0:	83 ec 18             	sub    $0x18,%esp
	cprintf("  edi  0x%08x\n", regs->reg_edi);
  1018e3:	8b 45 08             	mov    0x8(%ebp),%eax
  1018e6:	8b 00                	mov    (%eax),%eax
  1018e8:	89 44 24 04          	mov    %eax,0x4(%esp)
  1018ec:	c7 04 24 ab 34 10 00 	movl   $0x1034ab,(%esp)
  1018f3:	e8 78 e8 ff ff       	call   100170 <cprintf>
	cprintf("  esi  0x%08x\n", regs->reg_esi);
  1018f8:	8b 45 08             	mov    0x8(%ebp),%eax
  1018fb:	8b 40 04             	mov    0x4(%eax),%eax
  1018fe:	89 44 24 04          	mov    %eax,0x4(%esp)
  101902:	c7 04 24 ba 34 10 00 	movl   $0x1034ba,(%esp)
  101909:	e8 62 e8 ff ff       	call   100170 <cprintf>
	cprintf("  ebp  0x%08x\n", regs->reg_ebp);
  10190e:	8b 45 08             	mov    0x8(%ebp),%eax
  101911:	8b 40 08             	mov    0x8(%eax),%eax
  101914:	89 44 24 04          	mov    %eax,0x4(%esp)
  101918:	c7 04 24 c9 34 10 00 	movl   $0x1034c9,(%esp)
  10191f:	e8 4c e8 ff ff       	call   100170 <cprintf>
	cprintf("  oesp 0x%08x\n", regs->reg_oesp);
  101924:	8b 45 08             	mov    0x8(%ebp),%eax
  101927:	8b 40 0c             	mov    0xc(%eax),%eax
  10192a:	89 44 24 04          	mov    %eax,0x4(%esp)
  10192e:	c7 04 24 d8 34 10 00 	movl   $0x1034d8,(%esp)
  101935:	e8 36 e8 ff ff       	call   100170 <cprintf>
	cprintf("  ebx  0x%08x\n", regs->reg_ebx);
  10193a:	8b 45 08             	mov    0x8(%ebp),%eax
  10193d:	8b 40 10             	mov    0x10(%eax),%eax
  101940:	89 44 24 04          	mov    %eax,0x4(%esp)
  101944:	c7 04 24 e7 34 10 00 	movl   $0x1034e7,(%esp)
  10194b:	e8 20 e8 ff ff       	call   100170 <cprintf>
	cprintf("  edx  0x%08x\n", regs->reg_edx);
  101950:	8b 45 08             	mov    0x8(%ebp),%eax
  101953:	8b 40 14             	mov    0x14(%eax),%eax
  101956:	89 44 24 04          	mov    %eax,0x4(%esp)
  10195a:	c7 04 24 f6 34 10 00 	movl   $0x1034f6,(%esp)
  101961:	e8 0a e8 ff ff       	call   100170 <cprintf>
	cprintf("  ecx  0x%08x\n", regs->reg_ecx);
  101966:	8b 45 08             	mov    0x8(%ebp),%eax
  101969:	8b 40 18             	mov    0x18(%eax),%eax
  10196c:	89 44 24 04          	mov    %eax,0x4(%esp)
  101970:	c7 04 24 05 35 10 00 	movl   $0x103505,(%esp)
  101977:	e8 f4 e7 ff ff       	call   100170 <cprintf>
	cprintf("  eax  0x%08x\n", regs->reg_eax);
  10197c:	8b 45 08             	mov    0x8(%ebp),%eax
  10197f:	8b 40 1c             	mov    0x1c(%eax),%eax
  101982:	89 44 24 04          	mov    %eax,0x4(%esp)
  101986:	c7 04 24 14 35 10 00 	movl   $0x103514,(%esp)
  10198d:	e8 de e7 ff ff       	call   100170 <cprintf>
}
  101992:	c9                   	leave  
  101993:	c3                   	ret    

00101994 <trap_dispatch>:

/* trap_dispatch - dispatch based on what type of trap occurred */
static void trap_dispatch(struct trapframe *tf) 
{
  101994:	55                   	push   %ebp
  101995:	89 e5                	mov    %esp,%ebp
  101997:	83 ec 28             	sub    $0x28,%esp
	char c;
	switch (tf->tf_trapno) 
  10199a:	8b 45 08             	mov    0x8(%ebp),%eax
  10199d:	8b 40 28             	mov    0x28(%eax),%eax
  1019a0:	83 f8 21             	cmp    $0x21,%eax
  1019a3:	74 5f                	je     101a04 <trap_dispatch+0x70>
  1019a5:	83 f8 24             	cmp    $0x24,%eax
  1019a8:	74 34                	je     1019de <trap_dispatch+0x4a>
  1019aa:	83 f8 20             	cmp    $0x20,%eax
  1019ad:	75 7b                	jne    101a2a <trap_dispatch+0x96>
	{
		/* LAB1 YOUR CODE */
		/* handle the timer interrupt */
		case IRQ_OFFSET + IRQ_TIMER:
			time_trap_Num++;
  1019af:	a1 40 e0 10 00       	mov    0x10e040,%eax
  1019b4:	83 c0 01             	add    $0x1,%eax
  1019b7:	a3 40 e0 10 00       	mov    %eax,0x10e040
			if(time_trap_Num == TICK_NUM)
  1019bc:	a1 40 e0 10 00       	mov    0x10e040,%eax
  1019c1:	83 f8 64             	cmp    $0x64,%eax
  1019c4:	0f 85 98 00 00 00    	jne    101a62 <trap_dispatch+0xce>
			{
				time_trap_Num = 0;
  1019ca:	c7 05 40 e0 10 00 00 	movl   $0x0,0x10e040
  1019d1:	00 00 00 
				print_ticks();
  1019d4:	e8 83 fb ff ff       	call   10155c <print_ticks>
			}
			break;
  1019d9:	e9 85 00 00 00       	jmp    101a63 <trap_dispatch+0xcf>
		case IRQ_OFFSET + IRQ_COM1:
			c = cons_getc();
  1019de:	e8 54 f9 ff ff       	call   101337 <cons_getc>
  1019e3:	88 45 f7             	mov    %al,-0x9(%ebp)
			cprintf("serial [%03d] %c\n", c, c);
  1019e6:	0f be 55 f7          	movsbl -0x9(%ebp),%edx
  1019ea:	0f be 45 f7          	movsbl -0x9(%ebp),%eax
  1019ee:	89 54 24 08          	mov    %edx,0x8(%esp)
  1019f2:	89 44 24 04          	mov    %eax,0x4(%esp)
  1019f6:	c7 04 24 23 35 10 00 	movl   $0x103523,(%esp)
  1019fd:	e8 6e e7 ff ff       	call   100170 <cprintf>
			break;
  101a02:	eb 5f                	jmp    101a63 <trap_dispatch+0xcf>
		case IRQ_OFFSET + IRQ_KBD:
			c = cons_getc();
  101a04:	e8 2e f9 ff ff       	call   101337 <cons_getc>
  101a09:	88 45 f7             	mov    %al,-0x9(%ebp)
			cprintf("kbd [%03d] %c\n", c, c);
  101a0c:	0f be 55 f7          	movsbl -0x9(%ebp),%edx
  101a10:	0f be 45 f7          	movsbl -0x9(%ebp),%eax
  101a14:	89 54 24 08          	mov    %edx,0x8(%esp)
  101a18:	89 44 24 04          	mov    %eax,0x4(%esp)
  101a1c:	c7 04 24 35 35 10 00 	movl   $0x103535,(%esp)
  101a23:	e8 48 e7 ff ff       	call   100170 <cprintf>
			break;
  101a28:	eb 39                	jmp    101a63 <trap_dispatch+0xcf>
		default:
			// in kernel, it must be a mistake
		if ((tf->tf_cs & 3) == 0) 
  101a2a:	8b 45 08             	mov    0x8(%ebp),%eax
  101a2d:	0f b7 40 34          	movzwl 0x34(%eax),%eax
  101a31:	0f b7 c0             	movzwl %ax,%eax
  101a34:	83 e0 03             	and    $0x3,%eax
  101a37:	85 c0                	test   %eax,%eax
  101a39:	75 28                	jne    101a63 <trap_dispatch+0xcf>
		{
			print_trapframe(tf);
  101a3b:	8b 45 08             	mov    0x8(%ebp),%eax
  101a3e:	89 04 24             	mov    %eax,(%esp)
  101a41:	e8 06 fd ff ff       	call   10174c <print_trapframe>
			panic("unexpected trap in kernel.\n");
  101a46:	c7 44 24 08 44 35 10 	movl   $0x103544,0x8(%esp)
  101a4d:	00 
  101a4e:	c7 44 24 04 9f 00 00 	movl   $0x9f,0x4(%esp)
  101a55:	00 
  101a56:	c7 04 24 8e 33 10 00 	movl   $0x10338e,(%esp)
  101a5d:	e8 aa ef ff ff       	call   100a0c <__panic>
			if(time_trap_Num == TICK_NUM)
			{
				time_trap_Num = 0;
				print_ticks();
			}
			break;
  101a62:	90                   	nop
		{
			print_trapframe(tf);
			panic("unexpected trap in kernel.\n");
		}
	}
}
  101a63:	c9                   	leave  
  101a64:	c3                   	ret    

00101a65 <trap>:
 * trap - handles or dispatches an exception/interrupt. if and when trap() returns,
 * the code in kern/trap/trapentry.S restores the old CPU state saved in the
 * trapframe and then uses the iret instruction to return from the exception.
 * */
void
trap(struct trapframe *tf) {
  101a65:	55                   	push   %ebp
  101a66:	89 e5                	mov    %esp,%ebp
  101a68:	83 ec 18             	sub    $0x18,%esp
	trap_dispatch(tf);
  101a6b:	8b 45 08             	mov    0x8(%ebp),%eax
  101a6e:	89 04 24             	mov    %eax,(%esp)
  101a71:	e8 1e ff ff ff       	call   101994 <trap_dispatch>
}
  101a76:	c9                   	leave  
  101a77:	c3                   	ret    

00101a78 <__alltraps>:
.text
.globl __alltraps
__alltraps:
	# push registers to build a trap frame
	# therefore make the stack look like a struct trapframe
	pushl %ds
  101a78:	1e                   	push   %ds
	pushl %es
  101a79:	06                   	push   %es
	pushal
  101a7a:	60                   	pusha  

	# load GD_KDATA into %ds and %es to set up data segments for kernel
	movl $GD_KDATA, %eax
  101a7b:	b8 10 00 00 00       	mov    $0x10,%eax
	movw %ax, %ds
  101a80:	8e d8                	mov    %eax,%ds
	movw %ax, %es
  101a82:	8e c0                	mov    %eax,%es

	# push %esp to pass a pointer to the trapframe as an argument to trap()
	pushl %esp
  101a84:	54                   	push   %esp

	# call trap(tf), where tf=%esp
	call trap
  101a85:	e8 db ff ff ff       	call   101a65 <trap>

	# pop the pushed stack pointer
	popl %esp
  101a8a:	5c                   	pop    %esp

00101a8b <__trapret>:

	# return falls through to trapret...
.globl __trapret
__trapret:
	# restore registers from stack
	popal
  101a8b:	61                   	popa   

	# restore %ds and %es
	popl %es
  101a8c:	07                   	pop    %es
	popl %ds
  101a8d:	1f                   	pop    %ds

	# get rid of the trap number and error code
	addl $0x8, %esp
  101a8e:	83 c4 08             	add    $0x8,%esp
	iret
  101a91:	cf                   	iret   
	...

00101a94 <vector0>:
# handler
.text
.globl __alltraps
.globl vector0
vector0:
  pushl $0
  101a94:	6a 00                	push   $0x0
  pushl $0
  101a96:	6a 00                	push   $0x0
  jmp __alltraps
  101a98:	e9 db ff ff ff       	jmp    101a78 <__alltraps>

00101a9d <vector1>:
.globl vector1
vector1:
  pushl $0
  101a9d:	6a 00                	push   $0x0
  pushl $1
  101a9f:	6a 01                	push   $0x1
  jmp __alltraps
  101aa1:	e9 d2 ff ff ff       	jmp    101a78 <__alltraps>

00101aa6 <vector2>:
.globl vector2
vector2:
  pushl $0
  101aa6:	6a 00                	push   $0x0
  pushl $2
  101aa8:	6a 02                	push   $0x2
  jmp __alltraps
  101aaa:	e9 c9 ff ff ff       	jmp    101a78 <__alltraps>

00101aaf <vector3>:
.globl vector3
vector3:
  pushl $0
  101aaf:	6a 00                	push   $0x0
  pushl $3
  101ab1:	6a 03                	push   $0x3
  jmp __alltraps
  101ab3:	e9 c0 ff ff ff       	jmp    101a78 <__alltraps>

00101ab8 <vector4>:
.globl vector4
vector4:
  pushl $0
  101ab8:	6a 00                	push   $0x0
  pushl $4
  101aba:	6a 04                	push   $0x4
  jmp __alltraps
  101abc:	e9 b7 ff ff ff       	jmp    101a78 <__alltraps>

00101ac1 <vector5>:
.globl vector5
vector5:
  pushl $0
  101ac1:	6a 00                	push   $0x0
  pushl $5
  101ac3:	6a 05                	push   $0x5
  jmp __alltraps
  101ac5:	e9 ae ff ff ff       	jmp    101a78 <__alltraps>

00101aca <vector6>:
.globl vector6
vector6:
  pushl $0
  101aca:	6a 00                	push   $0x0
  pushl $6
  101acc:	6a 06                	push   $0x6
  jmp __alltraps
  101ace:	e9 a5 ff ff ff       	jmp    101a78 <__alltraps>

00101ad3 <vector7>:
.globl vector7
vector7:
  pushl $0
  101ad3:	6a 00                	push   $0x0
  pushl $7
  101ad5:	6a 07                	push   $0x7
  jmp __alltraps
  101ad7:	e9 9c ff ff ff       	jmp    101a78 <__alltraps>

00101adc <vector8>:
.globl vector8
vector8:
  pushl $8
  101adc:	6a 08                	push   $0x8
  jmp __alltraps
  101ade:	e9 95 ff ff ff       	jmp    101a78 <__alltraps>

00101ae3 <vector9>:
.globl vector9
vector9:
  pushl $9
  101ae3:	6a 09                	push   $0x9
  jmp __alltraps
  101ae5:	e9 8e ff ff ff       	jmp    101a78 <__alltraps>

00101aea <vector10>:
.globl vector10
vector10:
  pushl $10
  101aea:	6a 0a                	push   $0xa
  jmp __alltraps
  101aec:	e9 87 ff ff ff       	jmp    101a78 <__alltraps>

00101af1 <vector11>:
.globl vector11
vector11:
  pushl $11
  101af1:	6a 0b                	push   $0xb
  jmp __alltraps
  101af3:	e9 80 ff ff ff       	jmp    101a78 <__alltraps>

00101af8 <vector12>:
.globl vector12
vector12:
  pushl $12
  101af8:	6a 0c                	push   $0xc
  jmp __alltraps
  101afa:	e9 79 ff ff ff       	jmp    101a78 <__alltraps>

00101aff <vector13>:
.globl vector13
vector13:
  pushl $13
  101aff:	6a 0d                	push   $0xd
  jmp __alltraps
  101b01:	e9 72 ff ff ff       	jmp    101a78 <__alltraps>

00101b06 <vector14>:
.globl vector14
vector14:
  pushl $14
  101b06:	6a 0e                	push   $0xe
  jmp __alltraps
  101b08:	e9 6b ff ff ff       	jmp    101a78 <__alltraps>

00101b0d <vector15>:
.globl vector15
vector15:
  pushl $0
  101b0d:	6a 00                	push   $0x0
  pushl $15
  101b0f:	6a 0f                	push   $0xf
  jmp __alltraps
  101b11:	e9 62 ff ff ff       	jmp    101a78 <__alltraps>

00101b16 <vector16>:
.globl vector16
vector16:
  pushl $0
  101b16:	6a 00                	push   $0x0
  pushl $16
  101b18:	6a 10                	push   $0x10
  jmp __alltraps
  101b1a:	e9 59 ff ff ff       	jmp    101a78 <__alltraps>

00101b1f <vector17>:
.globl vector17
vector17:
  pushl $17
  101b1f:	6a 11                	push   $0x11
  jmp __alltraps
  101b21:	e9 52 ff ff ff       	jmp    101a78 <__alltraps>

00101b26 <vector18>:
.globl vector18
vector18:
  pushl $0
  101b26:	6a 00                	push   $0x0
  pushl $18
  101b28:	6a 12                	push   $0x12
  jmp __alltraps
  101b2a:	e9 49 ff ff ff       	jmp    101a78 <__alltraps>

00101b2f <vector19>:
.globl vector19
vector19:
  pushl $0
  101b2f:	6a 00                	push   $0x0
  pushl $19
  101b31:	6a 13                	push   $0x13
  jmp __alltraps
  101b33:	e9 40 ff ff ff       	jmp    101a78 <__alltraps>

00101b38 <vector20>:
.globl vector20
vector20:
  pushl $0
  101b38:	6a 00                	push   $0x0
  pushl $20
  101b3a:	6a 14                	push   $0x14
  jmp __alltraps
  101b3c:	e9 37 ff ff ff       	jmp    101a78 <__alltraps>

00101b41 <vector21>:
.globl vector21
vector21:
  pushl $0
  101b41:	6a 00                	push   $0x0
  pushl $21
  101b43:	6a 15                	push   $0x15
  jmp __alltraps
  101b45:	e9 2e ff ff ff       	jmp    101a78 <__alltraps>

00101b4a <vector22>:
.globl vector22
vector22:
  pushl $0
  101b4a:	6a 00                	push   $0x0
  pushl $22
  101b4c:	6a 16                	push   $0x16
  jmp __alltraps
  101b4e:	e9 25 ff ff ff       	jmp    101a78 <__alltraps>

00101b53 <vector23>:
.globl vector23
vector23:
  pushl $0
  101b53:	6a 00                	push   $0x0
  pushl $23
  101b55:	6a 17                	push   $0x17
  jmp __alltraps
  101b57:	e9 1c ff ff ff       	jmp    101a78 <__alltraps>

00101b5c <vector24>:
.globl vector24
vector24:
  pushl $0
  101b5c:	6a 00                	push   $0x0
  pushl $24
  101b5e:	6a 18                	push   $0x18
  jmp __alltraps
  101b60:	e9 13 ff ff ff       	jmp    101a78 <__alltraps>

00101b65 <vector25>:
.globl vector25
vector25:
  pushl $0
  101b65:	6a 00                	push   $0x0
  pushl $25
  101b67:	6a 19                	push   $0x19
  jmp __alltraps
  101b69:	e9 0a ff ff ff       	jmp    101a78 <__alltraps>

00101b6e <vector26>:
.globl vector26
vector26:
  pushl $0
  101b6e:	6a 00                	push   $0x0
  pushl $26
  101b70:	6a 1a                	push   $0x1a
  jmp __alltraps
  101b72:	e9 01 ff ff ff       	jmp    101a78 <__alltraps>

00101b77 <vector27>:
.globl vector27
vector27:
  pushl $0
  101b77:	6a 00                	push   $0x0
  pushl $27
  101b79:	6a 1b                	push   $0x1b
  jmp __alltraps
  101b7b:	e9 f8 fe ff ff       	jmp    101a78 <__alltraps>

00101b80 <vector28>:
.globl vector28
vector28:
  pushl $0
  101b80:	6a 00                	push   $0x0
  pushl $28
  101b82:	6a 1c                	push   $0x1c
  jmp __alltraps
  101b84:	e9 ef fe ff ff       	jmp    101a78 <__alltraps>

00101b89 <vector29>:
.globl vector29
vector29:
  pushl $0
  101b89:	6a 00                	push   $0x0
  pushl $29
  101b8b:	6a 1d                	push   $0x1d
  jmp __alltraps
  101b8d:	e9 e6 fe ff ff       	jmp    101a78 <__alltraps>

00101b92 <vector30>:
.globl vector30
vector30:
  pushl $0
  101b92:	6a 00                	push   $0x0
  pushl $30
  101b94:	6a 1e                	push   $0x1e
  jmp __alltraps
  101b96:	e9 dd fe ff ff       	jmp    101a78 <__alltraps>

00101b9b <vector31>:
.globl vector31
vector31:
  pushl $0
  101b9b:	6a 00                	push   $0x0
  pushl $31
  101b9d:	6a 1f                	push   $0x1f
  jmp __alltraps
  101b9f:	e9 d4 fe ff ff       	jmp    101a78 <__alltraps>

00101ba4 <vector32>:
.globl vector32
vector32:
  pushl $0
  101ba4:	6a 00                	push   $0x0
  pushl $32
  101ba6:	6a 20                	push   $0x20
  jmp __alltraps
  101ba8:	e9 cb fe ff ff       	jmp    101a78 <__alltraps>

00101bad <vector33>:
.globl vector33
vector33:
  pushl $0
  101bad:	6a 00                	push   $0x0
  pushl $33
  101baf:	6a 21                	push   $0x21
  jmp __alltraps
  101bb1:	e9 c2 fe ff ff       	jmp    101a78 <__alltraps>

00101bb6 <vector34>:
.globl vector34
vector34:
  pushl $0
  101bb6:	6a 00                	push   $0x0
  pushl $34
  101bb8:	6a 22                	push   $0x22
  jmp __alltraps
  101bba:	e9 b9 fe ff ff       	jmp    101a78 <__alltraps>

00101bbf <vector35>:
.globl vector35
vector35:
  pushl $0
  101bbf:	6a 00                	push   $0x0
  pushl $35
  101bc1:	6a 23                	push   $0x23
  jmp __alltraps
  101bc3:	e9 b0 fe ff ff       	jmp    101a78 <__alltraps>

00101bc8 <vector36>:
.globl vector36
vector36:
  pushl $0
  101bc8:	6a 00                	push   $0x0
  pushl $36
  101bca:	6a 24                	push   $0x24
  jmp __alltraps
  101bcc:	e9 a7 fe ff ff       	jmp    101a78 <__alltraps>

00101bd1 <vector37>:
.globl vector37
vector37:
  pushl $0
  101bd1:	6a 00                	push   $0x0
  pushl $37
  101bd3:	6a 25                	push   $0x25
  jmp __alltraps
  101bd5:	e9 9e fe ff ff       	jmp    101a78 <__alltraps>

00101bda <vector38>:
.globl vector38
vector38:
  pushl $0
  101bda:	6a 00                	push   $0x0
  pushl $38
  101bdc:	6a 26                	push   $0x26
  jmp __alltraps
  101bde:	e9 95 fe ff ff       	jmp    101a78 <__alltraps>

00101be3 <vector39>:
.globl vector39
vector39:
  pushl $0
  101be3:	6a 00                	push   $0x0
  pushl $39
  101be5:	6a 27                	push   $0x27
  jmp __alltraps
  101be7:	e9 8c fe ff ff       	jmp    101a78 <__alltraps>

00101bec <vector40>:
.globl vector40
vector40:
  pushl $0
  101bec:	6a 00                	push   $0x0
  pushl $40
  101bee:	6a 28                	push   $0x28
  jmp __alltraps
  101bf0:	e9 83 fe ff ff       	jmp    101a78 <__alltraps>

00101bf5 <vector41>:
.globl vector41
vector41:
  pushl $0
  101bf5:	6a 00                	push   $0x0
  pushl $41
  101bf7:	6a 29                	push   $0x29
  jmp __alltraps
  101bf9:	e9 7a fe ff ff       	jmp    101a78 <__alltraps>

00101bfe <vector42>:
.globl vector42
vector42:
  pushl $0
  101bfe:	6a 00                	push   $0x0
  pushl $42
  101c00:	6a 2a                	push   $0x2a
  jmp __alltraps
  101c02:	e9 71 fe ff ff       	jmp    101a78 <__alltraps>

00101c07 <vector43>:
.globl vector43
vector43:
  pushl $0
  101c07:	6a 00                	push   $0x0
  pushl $43
  101c09:	6a 2b                	push   $0x2b
  jmp __alltraps
  101c0b:	e9 68 fe ff ff       	jmp    101a78 <__alltraps>

00101c10 <vector44>:
.globl vector44
vector44:
  pushl $0
  101c10:	6a 00                	push   $0x0
  pushl $44
  101c12:	6a 2c                	push   $0x2c
  jmp __alltraps
  101c14:	e9 5f fe ff ff       	jmp    101a78 <__alltraps>

00101c19 <vector45>:
.globl vector45
vector45:
  pushl $0
  101c19:	6a 00                	push   $0x0
  pushl $45
  101c1b:	6a 2d                	push   $0x2d
  jmp __alltraps
  101c1d:	e9 56 fe ff ff       	jmp    101a78 <__alltraps>

00101c22 <vector46>:
.globl vector46
vector46:
  pushl $0
  101c22:	6a 00                	push   $0x0
  pushl $46
  101c24:	6a 2e                	push   $0x2e
  jmp __alltraps
  101c26:	e9 4d fe ff ff       	jmp    101a78 <__alltraps>

00101c2b <vector47>:
.globl vector47
vector47:
  pushl $0
  101c2b:	6a 00                	push   $0x0
  pushl $47
  101c2d:	6a 2f                	push   $0x2f
  jmp __alltraps
  101c2f:	e9 44 fe ff ff       	jmp    101a78 <__alltraps>

00101c34 <vector48>:
.globl vector48
vector48:
  pushl $0
  101c34:	6a 00                	push   $0x0
  pushl $48
  101c36:	6a 30                	push   $0x30
  jmp __alltraps
  101c38:	e9 3b fe ff ff       	jmp    101a78 <__alltraps>

00101c3d <vector49>:
.globl vector49
vector49:
  pushl $0
  101c3d:	6a 00                	push   $0x0
  pushl $49
  101c3f:	6a 31                	push   $0x31
  jmp __alltraps
  101c41:	e9 32 fe ff ff       	jmp    101a78 <__alltraps>

00101c46 <vector50>:
.globl vector50
vector50:
  pushl $0
  101c46:	6a 00                	push   $0x0
  pushl $50
  101c48:	6a 32                	push   $0x32
  jmp __alltraps
  101c4a:	e9 29 fe ff ff       	jmp    101a78 <__alltraps>

00101c4f <vector51>:
.globl vector51
vector51:
  pushl $0
  101c4f:	6a 00                	push   $0x0
  pushl $51
  101c51:	6a 33                	push   $0x33
  jmp __alltraps
  101c53:	e9 20 fe ff ff       	jmp    101a78 <__alltraps>

00101c58 <vector52>:
.globl vector52
vector52:
  pushl $0
  101c58:	6a 00                	push   $0x0
  pushl $52
  101c5a:	6a 34                	push   $0x34
  jmp __alltraps
  101c5c:	e9 17 fe ff ff       	jmp    101a78 <__alltraps>

00101c61 <vector53>:
.globl vector53
vector53:
  pushl $0
  101c61:	6a 00                	push   $0x0
  pushl $53
  101c63:	6a 35                	push   $0x35
  jmp __alltraps
  101c65:	e9 0e fe ff ff       	jmp    101a78 <__alltraps>

00101c6a <vector54>:
.globl vector54
vector54:
  pushl $0
  101c6a:	6a 00                	push   $0x0
  pushl $54
  101c6c:	6a 36                	push   $0x36
  jmp __alltraps
  101c6e:	e9 05 fe ff ff       	jmp    101a78 <__alltraps>

00101c73 <vector55>:
.globl vector55
vector55:
  pushl $0
  101c73:	6a 00                	push   $0x0
  pushl $55
  101c75:	6a 37                	push   $0x37
  jmp __alltraps
  101c77:	e9 fc fd ff ff       	jmp    101a78 <__alltraps>

00101c7c <vector56>:
.globl vector56
vector56:
  pushl $0
  101c7c:	6a 00                	push   $0x0
  pushl $56
  101c7e:	6a 38                	push   $0x38
  jmp __alltraps
  101c80:	e9 f3 fd ff ff       	jmp    101a78 <__alltraps>

00101c85 <vector57>:
.globl vector57
vector57:
  pushl $0
  101c85:	6a 00                	push   $0x0
  pushl $57
  101c87:	6a 39                	push   $0x39
  jmp __alltraps
  101c89:	e9 ea fd ff ff       	jmp    101a78 <__alltraps>

00101c8e <vector58>:
.globl vector58
vector58:
  pushl $0
  101c8e:	6a 00                	push   $0x0
  pushl $58
  101c90:	6a 3a                	push   $0x3a
  jmp __alltraps
  101c92:	e9 e1 fd ff ff       	jmp    101a78 <__alltraps>

00101c97 <vector59>:
.globl vector59
vector59:
  pushl $0
  101c97:	6a 00                	push   $0x0
  pushl $59
  101c99:	6a 3b                	push   $0x3b
  jmp __alltraps
  101c9b:	e9 d8 fd ff ff       	jmp    101a78 <__alltraps>

00101ca0 <vector60>:
.globl vector60
vector60:
  pushl $0
  101ca0:	6a 00                	push   $0x0
  pushl $60
  101ca2:	6a 3c                	push   $0x3c
  jmp __alltraps
  101ca4:	e9 cf fd ff ff       	jmp    101a78 <__alltraps>

00101ca9 <vector61>:
.globl vector61
vector61:
  pushl $0
  101ca9:	6a 00                	push   $0x0
  pushl $61
  101cab:	6a 3d                	push   $0x3d
  jmp __alltraps
  101cad:	e9 c6 fd ff ff       	jmp    101a78 <__alltraps>

00101cb2 <vector62>:
.globl vector62
vector62:
  pushl $0
  101cb2:	6a 00                	push   $0x0
  pushl $62
  101cb4:	6a 3e                	push   $0x3e
  jmp __alltraps
  101cb6:	e9 bd fd ff ff       	jmp    101a78 <__alltraps>

00101cbb <vector63>:
.globl vector63
vector63:
  pushl $0
  101cbb:	6a 00                	push   $0x0
  pushl $63
  101cbd:	6a 3f                	push   $0x3f
  jmp __alltraps
  101cbf:	e9 b4 fd ff ff       	jmp    101a78 <__alltraps>

00101cc4 <vector64>:
.globl vector64
vector64:
  pushl $0
  101cc4:	6a 00                	push   $0x0
  pushl $64
  101cc6:	6a 40                	push   $0x40
  jmp __alltraps
  101cc8:	e9 ab fd ff ff       	jmp    101a78 <__alltraps>

00101ccd <vector65>:
.globl vector65
vector65:
  pushl $0
  101ccd:	6a 00                	push   $0x0
  pushl $65
  101ccf:	6a 41                	push   $0x41
  jmp __alltraps
  101cd1:	e9 a2 fd ff ff       	jmp    101a78 <__alltraps>

00101cd6 <vector66>:
.globl vector66
vector66:
  pushl $0
  101cd6:	6a 00                	push   $0x0
  pushl $66
  101cd8:	6a 42                	push   $0x42
  jmp __alltraps
  101cda:	e9 99 fd ff ff       	jmp    101a78 <__alltraps>

00101cdf <vector67>:
.globl vector67
vector67:
  pushl $0
  101cdf:	6a 00                	push   $0x0
  pushl $67
  101ce1:	6a 43                	push   $0x43
  jmp __alltraps
  101ce3:	e9 90 fd ff ff       	jmp    101a78 <__alltraps>

00101ce8 <vector68>:
.globl vector68
vector68:
  pushl $0
  101ce8:	6a 00                	push   $0x0
  pushl $68
  101cea:	6a 44                	push   $0x44
  jmp __alltraps
  101cec:	e9 87 fd ff ff       	jmp    101a78 <__alltraps>

00101cf1 <vector69>:
.globl vector69
vector69:
  pushl $0
  101cf1:	6a 00                	push   $0x0
  pushl $69
  101cf3:	6a 45                	push   $0x45
  jmp __alltraps
  101cf5:	e9 7e fd ff ff       	jmp    101a78 <__alltraps>

00101cfa <vector70>:
.globl vector70
vector70:
  pushl $0
  101cfa:	6a 00                	push   $0x0
  pushl $70
  101cfc:	6a 46                	push   $0x46
  jmp __alltraps
  101cfe:	e9 75 fd ff ff       	jmp    101a78 <__alltraps>

00101d03 <vector71>:
.globl vector71
vector71:
  pushl $0
  101d03:	6a 00                	push   $0x0
  pushl $71
  101d05:	6a 47                	push   $0x47
  jmp __alltraps
  101d07:	e9 6c fd ff ff       	jmp    101a78 <__alltraps>

00101d0c <vector72>:
.globl vector72
vector72:
  pushl $0
  101d0c:	6a 00                	push   $0x0
  pushl $72
  101d0e:	6a 48                	push   $0x48
  jmp __alltraps
  101d10:	e9 63 fd ff ff       	jmp    101a78 <__alltraps>

00101d15 <vector73>:
.globl vector73
vector73:
  pushl $0
  101d15:	6a 00                	push   $0x0
  pushl $73
  101d17:	6a 49                	push   $0x49
  jmp __alltraps
  101d19:	e9 5a fd ff ff       	jmp    101a78 <__alltraps>

00101d1e <vector74>:
.globl vector74
vector74:
  pushl $0
  101d1e:	6a 00                	push   $0x0
  pushl $74
  101d20:	6a 4a                	push   $0x4a
  jmp __alltraps
  101d22:	e9 51 fd ff ff       	jmp    101a78 <__alltraps>

00101d27 <vector75>:
.globl vector75
vector75:
  pushl $0
  101d27:	6a 00                	push   $0x0
  pushl $75
  101d29:	6a 4b                	push   $0x4b
  jmp __alltraps
  101d2b:	e9 48 fd ff ff       	jmp    101a78 <__alltraps>

00101d30 <vector76>:
.globl vector76
vector76:
  pushl $0
  101d30:	6a 00                	push   $0x0
  pushl $76
  101d32:	6a 4c                	push   $0x4c
  jmp __alltraps
  101d34:	e9 3f fd ff ff       	jmp    101a78 <__alltraps>

00101d39 <vector77>:
.globl vector77
vector77:
  pushl $0
  101d39:	6a 00                	push   $0x0
  pushl $77
  101d3b:	6a 4d                	push   $0x4d
  jmp __alltraps
  101d3d:	e9 36 fd ff ff       	jmp    101a78 <__alltraps>

00101d42 <vector78>:
.globl vector78
vector78:
  pushl $0
  101d42:	6a 00                	push   $0x0
  pushl $78
  101d44:	6a 4e                	push   $0x4e
  jmp __alltraps
  101d46:	e9 2d fd ff ff       	jmp    101a78 <__alltraps>

00101d4b <vector79>:
.globl vector79
vector79:
  pushl $0
  101d4b:	6a 00                	push   $0x0
  pushl $79
  101d4d:	6a 4f                	push   $0x4f
  jmp __alltraps
  101d4f:	e9 24 fd ff ff       	jmp    101a78 <__alltraps>

00101d54 <vector80>:
.globl vector80
vector80:
  pushl $0
  101d54:	6a 00                	push   $0x0
  pushl $80
  101d56:	6a 50                	push   $0x50
  jmp __alltraps
  101d58:	e9 1b fd ff ff       	jmp    101a78 <__alltraps>

00101d5d <vector81>:
.globl vector81
vector81:
  pushl $0
  101d5d:	6a 00                	push   $0x0
  pushl $81
  101d5f:	6a 51                	push   $0x51
  jmp __alltraps
  101d61:	e9 12 fd ff ff       	jmp    101a78 <__alltraps>

00101d66 <vector82>:
.globl vector82
vector82:
  pushl $0
  101d66:	6a 00                	push   $0x0
  pushl $82
  101d68:	6a 52                	push   $0x52
  jmp __alltraps
  101d6a:	e9 09 fd ff ff       	jmp    101a78 <__alltraps>

00101d6f <vector83>:
.globl vector83
vector83:
  pushl $0
  101d6f:	6a 00                	push   $0x0
  pushl $83
  101d71:	6a 53                	push   $0x53
  jmp __alltraps
  101d73:	e9 00 fd ff ff       	jmp    101a78 <__alltraps>

00101d78 <vector84>:
.globl vector84
vector84:
  pushl $0
  101d78:	6a 00                	push   $0x0
  pushl $84
  101d7a:	6a 54                	push   $0x54
  jmp __alltraps
  101d7c:	e9 f7 fc ff ff       	jmp    101a78 <__alltraps>

00101d81 <vector85>:
.globl vector85
vector85:
  pushl $0
  101d81:	6a 00                	push   $0x0
  pushl $85
  101d83:	6a 55                	push   $0x55
  jmp __alltraps
  101d85:	e9 ee fc ff ff       	jmp    101a78 <__alltraps>

00101d8a <vector86>:
.globl vector86
vector86:
  pushl $0
  101d8a:	6a 00                	push   $0x0
  pushl $86
  101d8c:	6a 56                	push   $0x56
  jmp __alltraps
  101d8e:	e9 e5 fc ff ff       	jmp    101a78 <__alltraps>

00101d93 <vector87>:
.globl vector87
vector87:
  pushl $0
  101d93:	6a 00                	push   $0x0
  pushl $87
  101d95:	6a 57                	push   $0x57
  jmp __alltraps
  101d97:	e9 dc fc ff ff       	jmp    101a78 <__alltraps>

00101d9c <vector88>:
.globl vector88
vector88:
  pushl $0
  101d9c:	6a 00                	push   $0x0
  pushl $88
  101d9e:	6a 58                	push   $0x58
  jmp __alltraps
  101da0:	e9 d3 fc ff ff       	jmp    101a78 <__alltraps>

00101da5 <vector89>:
.globl vector89
vector89:
  pushl $0
  101da5:	6a 00                	push   $0x0
  pushl $89
  101da7:	6a 59                	push   $0x59
  jmp __alltraps
  101da9:	e9 ca fc ff ff       	jmp    101a78 <__alltraps>

00101dae <vector90>:
.globl vector90
vector90:
  pushl $0
  101dae:	6a 00                	push   $0x0
  pushl $90
  101db0:	6a 5a                	push   $0x5a
  jmp __alltraps
  101db2:	e9 c1 fc ff ff       	jmp    101a78 <__alltraps>

00101db7 <vector91>:
.globl vector91
vector91:
  pushl $0
  101db7:	6a 00                	push   $0x0
  pushl $91
  101db9:	6a 5b                	push   $0x5b
  jmp __alltraps
  101dbb:	e9 b8 fc ff ff       	jmp    101a78 <__alltraps>

00101dc0 <vector92>:
.globl vector92
vector92:
  pushl $0
  101dc0:	6a 00                	push   $0x0
  pushl $92
  101dc2:	6a 5c                	push   $0x5c
  jmp __alltraps
  101dc4:	e9 af fc ff ff       	jmp    101a78 <__alltraps>

00101dc9 <vector93>:
.globl vector93
vector93:
  pushl $0
  101dc9:	6a 00                	push   $0x0
  pushl $93
  101dcb:	6a 5d                	push   $0x5d
  jmp __alltraps
  101dcd:	e9 a6 fc ff ff       	jmp    101a78 <__alltraps>

00101dd2 <vector94>:
.globl vector94
vector94:
  pushl $0
  101dd2:	6a 00                	push   $0x0
  pushl $94
  101dd4:	6a 5e                	push   $0x5e
  jmp __alltraps
  101dd6:	e9 9d fc ff ff       	jmp    101a78 <__alltraps>

00101ddb <vector95>:
.globl vector95
vector95:
  pushl $0
  101ddb:	6a 00                	push   $0x0
  pushl $95
  101ddd:	6a 5f                	push   $0x5f
  jmp __alltraps
  101ddf:	e9 94 fc ff ff       	jmp    101a78 <__alltraps>

00101de4 <vector96>:
.globl vector96
vector96:
  pushl $0
  101de4:	6a 00                	push   $0x0
  pushl $96
  101de6:	6a 60                	push   $0x60
  jmp __alltraps
  101de8:	e9 8b fc ff ff       	jmp    101a78 <__alltraps>

00101ded <vector97>:
.globl vector97
vector97:
  pushl $0
  101ded:	6a 00                	push   $0x0
  pushl $97
  101def:	6a 61                	push   $0x61
  jmp __alltraps
  101df1:	e9 82 fc ff ff       	jmp    101a78 <__alltraps>

00101df6 <vector98>:
.globl vector98
vector98:
  pushl $0
  101df6:	6a 00                	push   $0x0
  pushl $98
  101df8:	6a 62                	push   $0x62
  jmp __alltraps
  101dfa:	e9 79 fc ff ff       	jmp    101a78 <__alltraps>

00101dff <vector99>:
.globl vector99
vector99:
  pushl $0
  101dff:	6a 00                	push   $0x0
  pushl $99
  101e01:	6a 63                	push   $0x63
  jmp __alltraps
  101e03:	e9 70 fc ff ff       	jmp    101a78 <__alltraps>

00101e08 <vector100>:
.globl vector100
vector100:
  pushl $0
  101e08:	6a 00                	push   $0x0
  pushl $100
  101e0a:	6a 64                	push   $0x64
  jmp __alltraps
  101e0c:	e9 67 fc ff ff       	jmp    101a78 <__alltraps>

00101e11 <vector101>:
.globl vector101
vector101:
  pushl $0
  101e11:	6a 00                	push   $0x0
  pushl $101
  101e13:	6a 65                	push   $0x65
  jmp __alltraps
  101e15:	e9 5e fc ff ff       	jmp    101a78 <__alltraps>

00101e1a <vector102>:
.globl vector102
vector102:
  pushl $0
  101e1a:	6a 00                	push   $0x0
  pushl $102
  101e1c:	6a 66                	push   $0x66
  jmp __alltraps
  101e1e:	e9 55 fc ff ff       	jmp    101a78 <__alltraps>

00101e23 <vector103>:
.globl vector103
vector103:
  pushl $0
  101e23:	6a 00                	push   $0x0
  pushl $103
  101e25:	6a 67                	push   $0x67
  jmp __alltraps
  101e27:	e9 4c fc ff ff       	jmp    101a78 <__alltraps>

00101e2c <vector104>:
.globl vector104
vector104:
  pushl $0
  101e2c:	6a 00                	push   $0x0
  pushl $104
  101e2e:	6a 68                	push   $0x68
  jmp __alltraps
  101e30:	e9 43 fc ff ff       	jmp    101a78 <__alltraps>

00101e35 <vector105>:
.globl vector105
vector105:
  pushl $0
  101e35:	6a 00                	push   $0x0
  pushl $105
  101e37:	6a 69                	push   $0x69
  jmp __alltraps
  101e39:	e9 3a fc ff ff       	jmp    101a78 <__alltraps>

00101e3e <vector106>:
.globl vector106
vector106:
  pushl $0
  101e3e:	6a 00                	push   $0x0
  pushl $106
  101e40:	6a 6a                	push   $0x6a
  jmp __alltraps
  101e42:	e9 31 fc ff ff       	jmp    101a78 <__alltraps>

00101e47 <vector107>:
.globl vector107
vector107:
  pushl $0
  101e47:	6a 00                	push   $0x0
  pushl $107
  101e49:	6a 6b                	push   $0x6b
  jmp __alltraps
  101e4b:	e9 28 fc ff ff       	jmp    101a78 <__alltraps>

00101e50 <vector108>:
.globl vector108
vector108:
  pushl $0
  101e50:	6a 00                	push   $0x0
  pushl $108
  101e52:	6a 6c                	push   $0x6c
  jmp __alltraps
  101e54:	e9 1f fc ff ff       	jmp    101a78 <__alltraps>

00101e59 <vector109>:
.globl vector109
vector109:
  pushl $0
  101e59:	6a 00                	push   $0x0
  pushl $109
  101e5b:	6a 6d                	push   $0x6d
  jmp __alltraps
  101e5d:	e9 16 fc ff ff       	jmp    101a78 <__alltraps>

00101e62 <vector110>:
.globl vector110
vector110:
  pushl $0
  101e62:	6a 00                	push   $0x0
  pushl $110
  101e64:	6a 6e                	push   $0x6e
  jmp __alltraps
  101e66:	e9 0d fc ff ff       	jmp    101a78 <__alltraps>

00101e6b <vector111>:
.globl vector111
vector111:
  pushl $0
  101e6b:	6a 00                	push   $0x0
  pushl $111
  101e6d:	6a 6f                	push   $0x6f
  jmp __alltraps
  101e6f:	e9 04 fc ff ff       	jmp    101a78 <__alltraps>

00101e74 <vector112>:
.globl vector112
vector112:
  pushl $0
  101e74:	6a 00                	push   $0x0
  pushl $112
  101e76:	6a 70                	push   $0x70
  jmp __alltraps
  101e78:	e9 fb fb ff ff       	jmp    101a78 <__alltraps>

00101e7d <vector113>:
.globl vector113
vector113:
  pushl $0
  101e7d:	6a 00                	push   $0x0
  pushl $113
  101e7f:	6a 71                	push   $0x71
  jmp __alltraps
  101e81:	e9 f2 fb ff ff       	jmp    101a78 <__alltraps>

00101e86 <vector114>:
.globl vector114
vector114:
  pushl $0
  101e86:	6a 00                	push   $0x0
  pushl $114
  101e88:	6a 72                	push   $0x72
  jmp __alltraps
  101e8a:	e9 e9 fb ff ff       	jmp    101a78 <__alltraps>

00101e8f <vector115>:
.globl vector115
vector115:
  pushl $0
  101e8f:	6a 00                	push   $0x0
  pushl $115
  101e91:	6a 73                	push   $0x73
  jmp __alltraps
  101e93:	e9 e0 fb ff ff       	jmp    101a78 <__alltraps>

00101e98 <vector116>:
.globl vector116
vector116:
  pushl $0
  101e98:	6a 00                	push   $0x0
  pushl $116
  101e9a:	6a 74                	push   $0x74
  jmp __alltraps
  101e9c:	e9 d7 fb ff ff       	jmp    101a78 <__alltraps>

00101ea1 <vector117>:
.globl vector117
vector117:
  pushl $0
  101ea1:	6a 00                	push   $0x0
  pushl $117
  101ea3:	6a 75                	push   $0x75
  jmp __alltraps
  101ea5:	e9 ce fb ff ff       	jmp    101a78 <__alltraps>

00101eaa <vector118>:
.globl vector118
vector118:
  pushl $0
  101eaa:	6a 00                	push   $0x0
  pushl $118
  101eac:	6a 76                	push   $0x76
  jmp __alltraps
  101eae:	e9 c5 fb ff ff       	jmp    101a78 <__alltraps>

00101eb3 <vector119>:
.globl vector119
vector119:
  pushl $0
  101eb3:	6a 00                	push   $0x0
  pushl $119
  101eb5:	6a 77                	push   $0x77
  jmp __alltraps
  101eb7:	e9 bc fb ff ff       	jmp    101a78 <__alltraps>

00101ebc <vector120>:
.globl vector120
vector120:
  pushl $0
  101ebc:	6a 00                	push   $0x0
  pushl $120
  101ebe:	6a 78                	push   $0x78
  jmp __alltraps
  101ec0:	e9 b3 fb ff ff       	jmp    101a78 <__alltraps>

00101ec5 <vector121>:
.globl vector121
vector121:
  pushl $0
  101ec5:	6a 00                	push   $0x0
  pushl $121
  101ec7:	6a 79                	push   $0x79
  jmp __alltraps
  101ec9:	e9 aa fb ff ff       	jmp    101a78 <__alltraps>

00101ece <vector122>:
.globl vector122
vector122:
  pushl $0
  101ece:	6a 00                	push   $0x0
  pushl $122
  101ed0:	6a 7a                	push   $0x7a
  jmp __alltraps
  101ed2:	e9 a1 fb ff ff       	jmp    101a78 <__alltraps>

00101ed7 <vector123>:
.globl vector123
vector123:
  pushl $0
  101ed7:	6a 00                	push   $0x0
  pushl $123
  101ed9:	6a 7b                	push   $0x7b
  jmp __alltraps
  101edb:	e9 98 fb ff ff       	jmp    101a78 <__alltraps>

00101ee0 <vector124>:
.globl vector124
vector124:
  pushl $0
  101ee0:	6a 00                	push   $0x0
  pushl $124
  101ee2:	6a 7c                	push   $0x7c
  jmp __alltraps
  101ee4:	e9 8f fb ff ff       	jmp    101a78 <__alltraps>

00101ee9 <vector125>:
.globl vector125
vector125:
  pushl $0
  101ee9:	6a 00                	push   $0x0
  pushl $125
  101eeb:	6a 7d                	push   $0x7d
  jmp __alltraps
  101eed:	e9 86 fb ff ff       	jmp    101a78 <__alltraps>

00101ef2 <vector126>:
.globl vector126
vector126:
  pushl $0
  101ef2:	6a 00                	push   $0x0
  pushl $126
  101ef4:	6a 7e                	push   $0x7e
  jmp __alltraps
  101ef6:	e9 7d fb ff ff       	jmp    101a78 <__alltraps>

00101efb <vector127>:
.globl vector127
vector127:
  pushl $0
  101efb:	6a 00                	push   $0x0
  pushl $127
  101efd:	6a 7f                	push   $0x7f
  jmp __alltraps
  101eff:	e9 74 fb ff ff       	jmp    101a78 <__alltraps>

00101f04 <vector128>:
.globl vector128
vector128:
  pushl $0
  101f04:	6a 00                	push   $0x0
  pushl $128
  101f06:	68 80 00 00 00       	push   $0x80
  jmp __alltraps
  101f0b:	e9 68 fb ff ff       	jmp    101a78 <__alltraps>

00101f10 <vector129>:
.globl vector129
vector129:
  pushl $0
  101f10:	6a 00                	push   $0x0
  pushl $129
  101f12:	68 81 00 00 00       	push   $0x81
  jmp __alltraps
  101f17:	e9 5c fb ff ff       	jmp    101a78 <__alltraps>

00101f1c <vector130>:
.globl vector130
vector130:
  pushl $0
  101f1c:	6a 00                	push   $0x0
  pushl $130
  101f1e:	68 82 00 00 00       	push   $0x82
  jmp __alltraps
  101f23:	e9 50 fb ff ff       	jmp    101a78 <__alltraps>

00101f28 <vector131>:
.globl vector131
vector131:
  pushl $0
  101f28:	6a 00                	push   $0x0
  pushl $131
  101f2a:	68 83 00 00 00       	push   $0x83
  jmp __alltraps
  101f2f:	e9 44 fb ff ff       	jmp    101a78 <__alltraps>

00101f34 <vector132>:
.globl vector132
vector132:
  pushl $0
  101f34:	6a 00                	push   $0x0
  pushl $132
  101f36:	68 84 00 00 00       	push   $0x84
  jmp __alltraps
  101f3b:	e9 38 fb ff ff       	jmp    101a78 <__alltraps>

00101f40 <vector133>:
.globl vector133
vector133:
  pushl $0
  101f40:	6a 00                	push   $0x0
  pushl $133
  101f42:	68 85 00 00 00       	push   $0x85
  jmp __alltraps
  101f47:	e9 2c fb ff ff       	jmp    101a78 <__alltraps>

00101f4c <vector134>:
.globl vector134
vector134:
  pushl $0
  101f4c:	6a 00                	push   $0x0
  pushl $134
  101f4e:	68 86 00 00 00       	push   $0x86
  jmp __alltraps
  101f53:	e9 20 fb ff ff       	jmp    101a78 <__alltraps>

00101f58 <vector135>:
.globl vector135
vector135:
  pushl $0
  101f58:	6a 00                	push   $0x0
  pushl $135
  101f5a:	68 87 00 00 00       	push   $0x87
  jmp __alltraps
  101f5f:	e9 14 fb ff ff       	jmp    101a78 <__alltraps>

00101f64 <vector136>:
.globl vector136
vector136:
  pushl $0
  101f64:	6a 00                	push   $0x0
  pushl $136
  101f66:	68 88 00 00 00       	push   $0x88
  jmp __alltraps
  101f6b:	e9 08 fb ff ff       	jmp    101a78 <__alltraps>

00101f70 <vector137>:
.globl vector137
vector137:
  pushl $0
  101f70:	6a 00                	push   $0x0
  pushl $137
  101f72:	68 89 00 00 00       	push   $0x89
  jmp __alltraps
  101f77:	e9 fc fa ff ff       	jmp    101a78 <__alltraps>

00101f7c <vector138>:
.globl vector138
vector138:
  pushl $0
  101f7c:	6a 00                	push   $0x0
  pushl $138
  101f7e:	68 8a 00 00 00       	push   $0x8a
  jmp __alltraps
  101f83:	e9 f0 fa ff ff       	jmp    101a78 <__alltraps>

00101f88 <vector139>:
.globl vector139
vector139:
  pushl $0
  101f88:	6a 00                	push   $0x0
  pushl $139
  101f8a:	68 8b 00 00 00       	push   $0x8b
  jmp __alltraps
  101f8f:	e9 e4 fa ff ff       	jmp    101a78 <__alltraps>

00101f94 <vector140>:
.globl vector140
vector140:
  pushl $0
  101f94:	6a 00                	push   $0x0
  pushl $140
  101f96:	68 8c 00 00 00       	push   $0x8c
  jmp __alltraps
  101f9b:	e9 d8 fa ff ff       	jmp    101a78 <__alltraps>

00101fa0 <vector141>:
.globl vector141
vector141:
  pushl $0
  101fa0:	6a 00                	push   $0x0
  pushl $141
  101fa2:	68 8d 00 00 00       	push   $0x8d
  jmp __alltraps
  101fa7:	e9 cc fa ff ff       	jmp    101a78 <__alltraps>

00101fac <vector142>:
.globl vector142
vector142:
  pushl $0
  101fac:	6a 00                	push   $0x0
  pushl $142
  101fae:	68 8e 00 00 00       	push   $0x8e
  jmp __alltraps
  101fb3:	e9 c0 fa ff ff       	jmp    101a78 <__alltraps>

00101fb8 <vector143>:
.globl vector143
vector143:
  pushl $0
  101fb8:	6a 00                	push   $0x0
  pushl $143
  101fba:	68 8f 00 00 00       	push   $0x8f
  jmp __alltraps
  101fbf:	e9 b4 fa ff ff       	jmp    101a78 <__alltraps>

00101fc4 <vector144>:
.globl vector144
vector144:
  pushl $0
  101fc4:	6a 00                	push   $0x0
  pushl $144
  101fc6:	68 90 00 00 00       	push   $0x90
  jmp __alltraps
  101fcb:	e9 a8 fa ff ff       	jmp    101a78 <__alltraps>

00101fd0 <vector145>:
.globl vector145
vector145:
  pushl $0
  101fd0:	6a 00                	push   $0x0
  pushl $145
  101fd2:	68 91 00 00 00       	push   $0x91
  jmp __alltraps
  101fd7:	e9 9c fa ff ff       	jmp    101a78 <__alltraps>

00101fdc <vector146>:
.globl vector146
vector146:
  pushl $0
  101fdc:	6a 00                	push   $0x0
  pushl $146
  101fde:	68 92 00 00 00       	push   $0x92
  jmp __alltraps
  101fe3:	e9 90 fa ff ff       	jmp    101a78 <__alltraps>

00101fe8 <vector147>:
.globl vector147
vector147:
  pushl $0
  101fe8:	6a 00                	push   $0x0
  pushl $147
  101fea:	68 93 00 00 00       	push   $0x93
  jmp __alltraps
  101fef:	e9 84 fa ff ff       	jmp    101a78 <__alltraps>

00101ff4 <vector148>:
.globl vector148
vector148:
  pushl $0
  101ff4:	6a 00                	push   $0x0
  pushl $148
  101ff6:	68 94 00 00 00       	push   $0x94
  jmp __alltraps
  101ffb:	e9 78 fa ff ff       	jmp    101a78 <__alltraps>

00102000 <vector149>:
.globl vector149
vector149:
  pushl $0
  102000:	6a 00                	push   $0x0
  pushl $149
  102002:	68 95 00 00 00       	push   $0x95
  jmp __alltraps
  102007:	e9 6c fa ff ff       	jmp    101a78 <__alltraps>

0010200c <vector150>:
.globl vector150
vector150:
  pushl $0
  10200c:	6a 00                	push   $0x0
  pushl $150
  10200e:	68 96 00 00 00       	push   $0x96
  jmp __alltraps
  102013:	e9 60 fa ff ff       	jmp    101a78 <__alltraps>

00102018 <vector151>:
.globl vector151
vector151:
  pushl $0
  102018:	6a 00                	push   $0x0
  pushl $151
  10201a:	68 97 00 00 00       	push   $0x97
  jmp __alltraps
  10201f:	e9 54 fa ff ff       	jmp    101a78 <__alltraps>

00102024 <vector152>:
.globl vector152
vector152:
  pushl $0
  102024:	6a 00                	push   $0x0
  pushl $152
  102026:	68 98 00 00 00       	push   $0x98
  jmp __alltraps
  10202b:	e9 48 fa ff ff       	jmp    101a78 <__alltraps>

00102030 <vector153>:
.globl vector153
vector153:
  pushl $0
  102030:	6a 00                	push   $0x0
  pushl $153
  102032:	68 99 00 00 00       	push   $0x99
  jmp __alltraps
  102037:	e9 3c fa ff ff       	jmp    101a78 <__alltraps>

0010203c <vector154>:
.globl vector154
vector154:
  pushl $0
  10203c:	6a 00                	push   $0x0
  pushl $154
  10203e:	68 9a 00 00 00       	push   $0x9a
  jmp __alltraps
  102043:	e9 30 fa ff ff       	jmp    101a78 <__alltraps>

00102048 <vector155>:
.globl vector155
vector155:
  pushl $0
  102048:	6a 00                	push   $0x0
  pushl $155
  10204a:	68 9b 00 00 00       	push   $0x9b
  jmp __alltraps
  10204f:	e9 24 fa ff ff       	jmp    101a78 <__alltraps>

00102054 <vector156>:
.globl vector156
vector156:
  pushl $0
  102054:	6a 00                	push   $0x0
  pushl $156
  102056:	68 9c 00 00 00       	push   $0x9c
  jmp __alltraps
  10205b:	e9 18 fa ff ff       	jmp    101a78 <__alltraps>

00102060 <vector157>:
.globl vector157
vector157:
  pushl $0
  102060:	6a 00                	push   $0x0
  pushl $157
  102062:	68 9d 00 00 00       	push   $0x9d
  jmp __alltraps
  102067:	e9 0c fa ff ff       	jmp    101a78 <__alltraps>

0010206c <vector158>:
.globl vector158
vector158:
  pushl $0
  10206c:	6a 00                	push   $0x0
  pushl $158
  10206e:	68 9e 00 00 00       	push   $0x9e
  jmp __alltraps
  102073:	e9 00 fa ff ff       	jmp    101a78 <__alltraps>

00102078 <vector159>:
.globl vector159
vector159:
  pushl $0
  102078:	6a 00                	push   $0x0
  pushl $159
  10207a:	68 9f 00 00 00       	push   $0x9f
  jmp __alltraps
  10207f:	e9 f4 f9 ff ff       	jmp    101a78 <__alltraps>

00102084 <vector160>:
.globl vector160
vector160:
  pushl $0
  102084:	6a 00                	push   $0x0
  pushl $160
  102086:	68 a0 00 00 00       	push   $0xa0
  jmp __alltraps
  10208b:	e9 e8 f9 ff ff       	jmp    101a78 <__alltraps>

00102090 <vector161>:
.globl vector161
vector161:
  pushl $0
  102090:	6a 00                	push   $0x0
  pushl $161
  102092:	68 a1 00 00 00       	push   $0xa1
  jmp __alltraps
  102097:	e9 dc f9 ff ff       	jmp    101a78 <__alltraps>

0010209c <vector162>:
.globl vector162
vector162:
  pushl $0
  10209c:	6a 00                	push   $0x0
  pushl $162
  10209e:	68 a2 00 00 00       	push   $0xa2
  jmp __alltraps
  1020a3:	e9 d0 f9 ff ff       	jmp    101a78 <__alltraps>

001020a8 <vector163>:
.globl vector163
vector163:
  pushl $0
  1020a8:	6a 00                	push   $0x0
  pushl $163
  1020aa:	68 a3 00 00 00       	push   $0xa3
  jmp __alltraps
  1020af:	e9 c4 f9 ff ff       	jmp    101a78 <__alltraps>

001020b4 <vector164>:
.globl vector164
vector164:
  pushl $0
  1020b4:	6a 00                	push   $0x0
  pushl $164
  1020b6:	68 a4 00 00 00       	push   $0xa4
  jmp __alltraps
  1020bb:	e9 b8 f9 ff ff       	jmp    101a78 <__alltraps>

001020c0 <vector165>:
.globl vector165
vector165:
  pushl $0
  1020c0:	6a 00                	push   $0x0
  pushl $165
  1020c2:	68 a5 00 00 00       	push   $0xa5
  jmp __alltraps
  1020c7:	e9 ac f9 ff ff       	jmp    101a78 <__alltraps>

001020cc <vector166>:
.globl vector166
vector166:
  pushl $0
  1020cc:	6a 00                	push   $0x0
  pushl $166
  1020ce:	68 a6 00 00 00       	push   $0xa6
  jmp __alltraps
  1020d3:	e9 a0 f9 ff ff       	jmp    101a78 <__alltraps>

001020d8 <vector167>:
.globl vector167
vector167:
  pushl $0
  1020d8:	6a 00                	push   $0x0
  pushl $167
  1020da:	68 a7 00 00 00       	push   $0xa7
  jmp __alltraps
  1020df:	e9 94 f9 ff ff       	jmp    101a78 <__alltraps>

001020e4 <vector168>:
.globl vector168
vector168:
  pushl $0
  1020e4:	6a 00                	push   $0x0
  pushl $168
  1020e6:	68 a8 00 00 00       	push   $0xa8
  jmp __alltraps
  1020eb:	e9 88 f9 ff ff       	jmp    101a78 <__alltraps>

001020f0 <vector169>:
.globl vector169
vector169:
  pushl $0
  1020f0:	6a 00                	push   $0x0
  pushl $169
  1020f2:	68 a9 00 00 00       	push   $0xa9
  jmp __alltraps
  1020f7:	e9 7c f9 ff ff       	jmp    101a78 <__alltraps>

001020fc <vector170>:
.globl vector170
vector170:
  pushl $0
  1020fc:	6a 00                	push   $0x0
  pushl $170
  1020fe:	68 aa 00 00 00       	push   $0xaa
  jmp __alltraps
  102103:	e9 70 f9 ff ff       	jmp    101a78 <__alltraps>

00102108 <vector171>:
.globl vector171
vector171:
  pushl $0
  102108:	6a 00                	push   $0x0
  pushl $171
  10210a:	68 ab 00 00 00       	push   $0xab
  jmp __alltraps
  10210f:	e9 64 f9 ff ff       	jmp    101a78 <__alltraps>

00102114 <vector172>:
.globl vector172
vector172:
  pushl $0
  102114:	6a 00                	push   $0x0
  pushl $172
  102116:	68 ac 00 00 00       	push   $0xac
  jmp __alltraps
  10211b:	e9 58 f9 ff ff       	jmp    101a78 <__alltraps>

00102120 <vector173>:
.globl vector173
vector173:
  pushl $0
  102120:	6a 00                	push   $0x0
  pushl $173
  102122:	68 ad 00 00 00       	push   $0xad
  jmp __alltraps
  102127:	e9 4c f9 ff ff       	jmp    101a78 <__alltraps>

0010212c <vector174>:
.globl vector174
vector174:
  pushl $0
  10212c:	6a 00                	push   $0x0
  pushl $174
  10212e:	68 ae 00 00 00       	push   $0xae
  jmp __alltraps
  102133:	e9 40 f9 ff ff       	jmp    101a78 <__alltraps>

00102138 <vector175>:
.globl vector175
vector175:
  pushl $0
  102138:	6a 00                	push   $0x0
  pushl $175
  10213a:	68 af 00 00 00       	push   $0xaf
  jmp __alltraps
  10213f:	e9 34 f9 ff ff       	jmp    101a78 <__alltraps>

00102144 <vector176>:
.globl vector176
vector176:
  pushl $0
  102144:	6a 00                	push   $0x0
  pushl $176
  102146:	68 b0 00 00 00       	push   $0xb0
  jmp __alltraps
  10214b:	e9 28 f9 ff ff       	jmp    101a78 <__alltraps>

00102150 <vector177>:
.globl vector177
vector177:
  pushl $0
  102150:	6a 00                	push   $0x0
  pushl $177
  102152:	68 b1 00 00 00       	push   $0xb1
  jmp __alltraps
  102157:	e9 1c f9 ff ff       	jmp    101a78 <__alltraps>

0010215c <vector178>:
.globl vector178
vector178:
  pushl $0
  10215c:	6a 00                	push   $0x0
  pushl $178
  10215e:	68 b2 00 00 00       	push   $0xb2
  jmp __alltraps
  102163:	e9 10 f9 ff ff       	jmp    101a78 <__alltraps>

00102168 <vector179>:
.globl vector179
vector179:
  pushl $0
  102168:	6a 00                	push   $0x0
  pushl $179
  10216a:	68 b3 00 00 00       	push   $0xb3
  jmp __alltraps
  10216f:	e9 04 f9 ff ff       	jmp    101a78 <__alltraps>

00102174 <vector180>:
.globl vector180
vector180:
  pushl $0
  102174:	6a 00                	push   $0x0
  pushl $180
  102176:	68 b4 00 00 00       	push   $0xb4
  jmp __alltraps
  10217b:	e9 f8 f8 ff ff       	jmp    101a78 <__alltraps>

00102180 <vector181>:
.globl vector181
vector181:
  pushl $0
  102180:	6a 00                	push   $0x0
  pushl $181
  102182:	68 b5 00 00 00       	push   $0xb5
  jmp __alltraps
  102187:	e9 ec f8 ff ff       	jmp    101a78 <__alltraps>

0010218c <vector182>:
.globl vector182
vector182:
  pushl $0
  10218c:	6a 00                	push   $0x0
  pushl $182
  10218e:	68 b6 00 00 00       	push   $0xb6
  jmp __alltraps
  102193:	e9 e0 f8 ff ff       	jmp    101a78 <__alltraps>

00102198 <vector183>:
.globl vector183
vector183:
  pushl $0
  102198:	6a 00                	push   $0x0
  pushl $183
  10219a:	68 b7 00 00 00       	push   $0xb7
  jmp __alltraps
  10219f:	e9 d4 f8 ff ff       	jmp    101a78 <__alltraps>

001021a4 <vector184>:
.globl vector184
vector184:
  pushl $0
  1021a4:	6a 00                	push   $0x0
  pushl $184
  1021a6:	68 b8 00 00 00       	push   $0xb8
  jmp __alltraps
  1021ab:	e9 c8 f8 ff ff       	jmp    101a78 <__alltraps>

001021b0 <vector185>:
.globl vector185
vector185:
  pushl $0
  1021b0:	6a 00                	push   $0x0
  pushl $185
  1021b2:	68 b9 00 00 00       	push   $0xb9
  jmp __alltraps
  1021b7:	e9 bc f8 ff ff       	jmp    101a78 <__alltraps>

001021bc <vector186>:
.globl vector186
vector186:
  pushl $0
  1021bc:	6a 00                	push   $0x0
  pushl $186
  1021be:	68 ba 00 00 00       	push   $0xba
  jmp __alltraps
  1021c3:	e9 b0 f8 ff ff       	jmp    101a78 <__alltraps>

001021c8 <vector187>:
.globl vector187
vector187:
  pushl $0
  1021c8:	6a 00                	push   $0x0
  pushl $187
  1021ca:	68 bb 00 00 00       	push   $0xbb
  jmp __alltraps
  1021cf:	e9 a4 f8 ff ff       	jmp    101a78 <__alltraps>

001021d4 <vector188>:
.globl vector188
vector188:
  pushl $0
  1021d4:	6a 00                	push   $0x0
  pushl $188
  1021d6:	68 bc 00 00 00       	push   $0xbc
  jmp __alltraps
  1021db:	e9 98 f8 ff ff       	jmp    101a78 <__alltraps>

001021e0 <vector189>:
.globl vector189
vector189:
  pushl $0
  1021e0:	6a 00                	push   $0x0
  pushl $189
  1021e2:	68 bd 00 00 00       	push   $0xbd
  jmp __alltraps
  1021e7:	e9 8c f8 ff ff       	jmp    101a78 <__alltraps>

001021ec <vector190>:
.globl vector190
vector190:
  pushl $0
  1021ec:	6a 00                	push   $0x0
  pushl $190
  1021ee:	68 be 00 00 00       	push   $0xbe
  jmp __alltraps
  1021f3:	e9 80 f8 ff ff       	jmp    101a78 <__alltraps>

001021f8 <vector191>:
.globl vector191
vector191:
  pushl $0
  1021f8:	6a 00                	push   $0x0
  pushl $191
  1021fa:	68 bf 00 00 00       	push   $0xbf
  jmp __alltraps
  1021ff:	e9 74 f8 ff ff       	jmp    101a78 <__alltraps>

00102204 <vector192>:
.globl vector192
vector192:
  pushl $0
  102204:	6a 00                	push   $0x0
  pushl $192
  102206:	68 c0 00 00 00       	push   $0xc0
  jmp __alltraps
  10220b:	e9 68 f8 ff ff       	jmp    101a78 <__alltraps>

00102210 <vector193>:
.globl vector193
vector193:
  pushl $0
  102210:	6a 00                	push   $0x0
  pushl $193
  102212:	68 c1 00 00 00       	push   $0xc1
  jmp __alltraps
  102217:	e9 5c f8 ff ff       	jmp    101a78 <__alltraps>

0010221c <vector194>:
.globl vector194
vector194:
  pushl $0
  10221c:	6a 00                	push   $0x0
  pushl $194
  10221e:	68 c2 00 00 00       	push   $0xc2
  jmp __alltraps
  102223:	e9 50 f8 ff ff       	jmp    101a78 <__alltraps>

00102228 <vector195>:
.globl vector195
vector195:
  pushl $0
  102228:	6a 00                	push   $0x0
  pushl $195
  10222a:	68 c3 00 00 00       	push   $0xc3
  jmp __alltraps
  10222f:	e9 44 f8 ff ff       	jmp    101a78 <__alltraps>

00102234 <vector196>:
.globl vector196
vector196:
  pushl $0
  102234:	6a 00                	push   $0x0
  pushl $196
  102236:	68 c4 00 00 00       	push   $0xc4
  jmp __alltraps
  10223b:	e9 38 f8 ff ff       	jmp    101a78 <__alltraps>

00102240 <vector197>:
.globl vector197
vector197:
  pushl $0
  102240:	6a 00                	push   $0x0
  pushl $197
  102242:	68 c5 00 00 00       	push   $0xc5
  jmp __alltraps
  102247:	e9 2c f8 ff ff       	jmp    101a78 <__alltraps>

0010224c <vector198>:
.globl vector198
vector198:
  pushl $0
  10224c:	6a 00                	push   $0x0
  pushl $198
  10224e:	68 c6 00 00 00       	push   $0xc6
  jmp __alltraps
  102253:	e9 20 f8 ff ff       	jmp    101a78 <__alltraps>

00102258 <vector199>:
.globl vector199
vector199:
  pushl $0
  102258:	6a 00                	push   $0x0
  pushl $199
  10225a:	68 c7 00 00 00       	push   $0xc7
  jmp __alltraps
  10225f:	e9 14 f8 ff ff       	jmp    101a78 <__alltraps>

00102264 <vector200>:
.globl vector200
vector200:
  pushl $0
  102264:	6a 00                	push   $0x0
  pushl $200
  102266:	68 c8 00 00 00       	push   $0xc8
  jmp __alltraps
  10226b:	e9 08 f8 ff ff       	jmp    101a78 <__alltraps>

00102270 <vector201>:
.globl vector201
vector201:
  pushl $0
  102270:	6a 00                	push   $0x0
  pushl $201
  102272:	68 c9 00 00 00       	push   $0xc9
  jmp __alltraps
  102277:	e9 fc f7 ff ff       	jmp    101a78 <__alltraps>

0010227c <vector202>:
.globl vector202
vector202:
  pushl $0
  10227c:	6a 00                	push   $0x0
  pushl $202
  10227e:	68 ca 00 00 00       	push   $0xca
  jmp __alltraps
  102283:	e9 f0 f7 ff ff       	jmp    101a78 <__alltraps>

00102288 <vector203>:
.globl vector203
vector203:
  pushl $0
  102288:	6a 00                	push   $0x0
  pushl $203
  10228a:	68 cb 00 00 00       	push   $0xcb
  jmp __alltraps
  10228f:	e9 e4 f7 ff ff       	jmp    101a78 <__alltraps>

00102294 <vector204>:
.globl vector204
vector204:
  pushl $0
  102294:	6a 00                	push   $0x0
  pushl $204
  102296:	68 cc 00 00 00       	push   $0xcc
  jmp __alltraps
  10229b:	e9 d8 f7 ff ff       	jmp    101a78 <__alltraps>

001022a0 <vector205>:
.globl vector205
vector205:
  pushl $0
  1022a0:	6a 00                	push   $0x0
  pushl $205
  1022a2:	68 cd 00 00 00       	push   $0xcd
  jmp __alltraps
  1022a7:	e9 cc f7 ff ff       	jmp    101a78 <__alltraps>

001022ac <vector206>:
.globl vector206
vector206:
  pushl $0
  1022ac:	6a 00                	push   $0x0
  pushl $206
  1022ae:	68 ce 00 00 00       	push   $0xce
  jmp __alltraps
  1022b3:	e9 c0 f7 ff ff       	jmp    101a78 <__alltraps>

001022b8 <vector207>:
.globl vector207
vector207:
  pushl $0
  1022b8:	6a 00                	push   $0x0
  pushl $207
  1022ba:	68 cf 00 00 00       	push   $0xcf
  jmp __alltraps
  1022bf:	e9 b4 f7 ff ff       	jmp    101a78 <__alltraps>

001022c4 <vector208>:
.globl vector208
vector208:
  pushl $0
  1022c4:	6a 00                	push   $0x0
  pushl $208
  1022c6:	68 d0 00 00 00       	push   $0xd0
  jmp __alltraps
  1022cb:	e9 a8 f7 ff ff       	jmp    101a78 <__alltraps>

001022d0 <vector209>:
.globl vector209
vector209:
  pushl $0
  1022d0:	6a 00                	push   $0x0
  pushl $209
  1022d2:	68 d1 00 00 00       	push   $0xd1
  jmp __alltraps
  1022d7:	e9 9c f7 ff ff       	jmp    101a78 <__alltraps>

001022dc <vector210>:
.globl vector210
vector210:
  pushl $0
  1022dc:	6a 00                	push   $0x0
  pushl $210
  1022de:	68 d2 00 00 00       	push   $0xd2
  jmp __alltraps
  1022e3:	e9 90 f7 ff ff       	jmp    101a78 <__alltraps>

001022e8 <vector211>:
.globl vector211
vector211:
  pushl $0
  1022e8:	6a 00                	push   $0x0
  pushl $211
  1022ea:	68 d3 00 00 00       	push   $0xd3
  jmp __alltraps
  1022ef:	e9 84 f7 ff ff       	jmp    101a78 <__alltraps>

001022f4 <vector212>:
.globl vector212
vector212:
  pushl $0
  1022f4:	6a 00                	push   $0x0
  pushl $212
  1022f6:	68 d4 00 00 00       	push   $0xd4
  jmp __alltraps
  1022fb:	e9 78 f7 ff ff       	jmp    101a78 <__alltraps>

00102300 <vector213>:
.globl vector213
vector213:
  pushl $0
  102300:	6a 00                	push   $0x0
  pushl $213
  102302:	68 d5 00 00 00       	push   $0xd5
  jmp __alltraps
  102307:	e9 6c f7 ff ff       	jmp    101a78 <__alltraps>

0010230c <vector214>:
.globl vector214
vector214:
  pushl $0
  10230c:	6a 00                	push   $0x0
  pushl $214
  10230e:	68 d6 00 00 00       	push   $0xd6
  jmp __alltraps
  102313:	e9 60 f7 ff ff       	jmp    101a78 <__alltraps>

00102318 <vector215>:
.globl vector215
vector215:
  pushl $0
  102318:	6a 00                	push   $0x0
  pushl $215
  10231a:	68 d7 00 00 00       	push   $0xd7
  jmp __alltraps
  10231f:	e9 54 f7 ff ff       	jmp    101a78 <__alltraps>

00102324 <vector216>:
.globl vector216
vector216:
  pushl $0
  102324:	6a 00                	push   $0x0
  pushl $216
  102326:	68 d8 00 00 00       	push   $0xd8
  jmp __alltraps
  10232b:	e9 48 f7 ff ff       	jmp    101a78 <__alltraps>

00102330 <vector217>:
.globl vector217
vector217:
  pushl $0
  102330:	6a 00                	push   $0x0
  pushl $217
  102332:	68 d9 00 00 00       	push   $0xd9
  jmp __alltraps
  102337:	e9 3c f7 ff ff       	jmp    101a78 <__alltraps>

0010233c <vector218>:
.globl vector218
vector218:
  pushl $0
  10233c:	6a 00                	push   $0x0
  pushl $218
  10233e:	68 da 00 00 00       	push   $0xda
  jmp __alltraps
  102343:	e9 30 f7 ff ff       	jmp    101a78 <__alltraps>

00102348 <vector219>:
.globl vector219
vector219:
  pushl $0
  102348:	6a 00                	push   $0x0
  pushl $219
  10234a:	68 db 00 00 00       	push   $0xdb
  jmp __alltraps
  10234f:	e9 24 f7 ff ff       	jmp    101a78 <__alltraps>

00102354 <vector220>:
.globl vector220
vector220:
  pushl $0
  102354:	6a 00                	push   $0x0
  pushl $220
  102356:	68 dc 00 00 00       	push   $0xdc
  jmp __alltraps
  10235b:	e9 18 f7 ff ff       	jmp    101a78 <__alltraps>

00102360 <vector221>:
.globl vector221
vector221:
  pushl $0
  102360:	6a 00                	push   $0x0
  pushl $221
  102362:	68 dd 00 00 00       	push   $0xdd
  jmp __alltraps
  102367:	e9 0c f7 ff ff       	jmp    101a78 <__alltraps>

0010236c <vector222>:
.globl vector222
vector222:
  pushl $0
  10236c:	6a 00                	push   $0x0
  pushl $222
  10236e:	68 de 00 00 00       	push   $0xde
  jmp __alltraps
  102373:	e9 00 f7 ff ff       	jmp    101a78 <__alltraps>

00102378 <vector223>:
.globl vector223
vector223:
  pushl $0
  102378:	6a 00                	push   $0x0
  pushl $223
  10237a:	68 df 00 00 00       	push   $0xdf
  jmp __alltraps
  10237f:	e9 f4 f6 ff ff       	jmp    101a78 <__alltraps>

00102384 <vector224>:
.globl vector224
vector224:
  pushl $0
  102384:	6a 00                	push   $0x0
  pushl $224
  102386:	68 e0 00 00 00       	push   $0xe0
  jmp __alltraps
  10238b:	e9 e8 f6 ff ff       	jmp    101a78 <__alltraps>

00102390 <vector225>:
.globl vector225
vector225:
  pushl $0
  102390:	6a 00                	push   $0x0
  pushl $225
  102392:	68 e1 00 00 00       	push   $0xe1
  jmp __alltraps
  102397:	e9 dc f6 ff ff       	jmp    101a78 <__alltraps>

0010239c <vector226>:
.globl vector226
vector226:
  pushl $0
  10239c:	6a 00                	push   $0x0
  pushl $226
  10239e:	68 e2 00 00 00       	push   $0xe2
  jmp __alltraps
  1023a3:	e9 d0 f6 ff ff       	jmp    101a78 <__alltraps>

001023a8 <vector227>:
.globl vector227
vector227:
  pushl $0
  1023a8:	6a 00                	push   $0x0
  pushl $227
  1023aa:	68 e3 00 00 00       	push   $0xe3
  jmp __alltraps
  1023af:	e9 c4 f6 ff ff       	jmp    101a78 <__alltraps>

001023b4 <vector228>:
.globl vector228
vector228:
  pushl $0
  1023b4:	6a 00                	push   $0x0
  pushl $228
  1023b6:	68 e4 00 00 00       	push   $0xe4
  jmp __alltraps
  1023bb:	e9 b8 f6 ff ff       	jmp    101a78 <__alltraps>

001023c0 <vector229>:
.globl vector229
vector229:
  pushl $0
  1023c0:	6a 00                	push   $0x0
  pushl $229
  1023c2:	68 e5 00 00 00       	push   $0xe5
  jmp __alltraps
  1023c7:	e9 ac f6 ff ff       	jmp    101a78 <__alltraps>

001023cc <vector230>:
.globl vector230
vector230:
  pushl $0
  1023cc:	6a 00                	push   $0x0
  pushl $230
  1023ce:	68 e6 00 00 00       	push   $0xe6
  jmp __alltraps
  1023d3:	e9 a0 f6 ff ff       	jmp    101a78 <__alltraps>

001023d8 <vector231>:
.globl vector231
vector231:
  pushl $0
  1023d8:	6a 00                	push   $0x0
  pushl $231
  1023da:	68 e7 00 00 00       	push   $0xe7
  jmp __alltraps
  1023df:	e9 94 f6 ff ff       	jmp    101a78 <__alltraps>

001023e4 <vector232>:
.globl vector232
vector232:
  pushl $0
  1023e4:	6a 00                	push   $0x0
  pushl $232
  1023e6:	68 e8 00 00 00       	push   $0xe8
  jmp __alltraps
  1023eb:	e9 88 f6 ff ff       	jmp    101a78 <__alltraps>

001023f0 <vector233>:
.globl vector233
vector233:
  pushl $0
  1023f0:	6a 00                	push   $0x0
  pushl $233
  1023f2:	68 e9 00 00 00       	push   $0xe9
  jmp __alltraps
  1023f7:	e9 7c f6 ff ff       	jmp    101a78 <__alltraps>

001023fc <vector234>:
.globl vector234
vector234:
  pushl $0
  1023fc:	6a 00                	push   $0x0
  pushl $234
  1023fe:	68 ea 00 00 00       	push   $0xea
  jmp __alltraps
  102403:	e9 70 f6 ff ff       	jmp    101a78 <__alltraps>

00102408 <vector235>:
.globl vector235
vector235:
  pushl $0
  102408:	6a 00                	push   $0x0
  pushl $235
  10240a:	68 eb 00 00 00       	push   $0xeb
  jmp __alltraps
  10240f:	e9 64 f6 ff ff       	jmp    101a78 <__alltraps>

00102414 <vector236>:
.globl vector236
vector236:
  pushl $0
  102414:	6a 00                	push   $0x0
  pushl $236
  102416:	68 ec 00 00 00       	push   $0xec
  jmp __alltraps
  10241b:	e9 58 f6 ff ff       	jmp    101a78 <__alltraps>

00102420 <vector237>:
.globl vector237
vector237:
  pushl $0
  102420:	6a 00                	push   $0x0
  pushl $237
  102422:	68 ed 00 00 00       	push   $0xed
  jmp __alltraps
  102427:	e9 4c f6 ff ff       	jmp    101a78 <__alltraps>

0010242c <vector238>:
.globl vector238
vector238:
  pushl $0
  10242c:	6a 00                	push   $0x0
  pushl $238
  10242e:	68 ee 00 00 00       	push   $0xee
  jmp __alltraps
  102433:	e9 40 f6 ff ff       	jmp    101a78 <__alltraps>

00102438 <vector239>:
.globl vector239
vector239:
  pushl $0
  102438:	6a 00                	push   $0x0
  pushl $239
  10243a:	68 ef 00 00 00       	push   $0xef
  jmp __alltraps
  10243f:	e9 34 f6 ff ff       	jmp    101a78 <__alltraps>

00102444 <vector240>:
.globl vector240
vector240:
  pushl $0
  102444:	6a 00                	push   $0x0
  pushl $240
  102446:	68 f0 00 00 00       	push   $0xf0
  jmp __alltraps
  10244b:	e9 28 f6 ff ff       	jmp    101a78 <__alltraps>

00102450 <vector241>:
.globl vector241
vector241:
  pushl $0
  102450:	6a 00                	push   $0x0
  pushl $241
  102452:	68 f1 00 00 00       	push   $0xf1
  jmp __alltraps
  102457:	e9 1c f6 ff ff       	jmp    101a78 <__alltraps>

0010245c <vector242>:
.globl vector242
vector242:
  pushl $0
  10245c:	6a 00                	push   $0x0
  pushl $242
  10245e:	68 f2 00 00 00       	push   $0xf2
  jmp __alltraps
  102463:	e9 10 f6 ff ff       	jmp    101a78 <__alltraps>

00102468 <vector243>:
.globl vector243
vector243:
  pushl $0
  102468:	6a 00                	push   $0x0
  pushl $243
  10246a:	68 f3 00 00 00       	push   $0xf3
  jmp __alltraps
  10246f:	e9 04 f6 ff ff       	jmp    101a78 <__alltraps>

00102474 <vector244>:
.globl vector244
vector244:
  pushl $0
  102474:	6a 00                	push   $0x0
  pushl $244
  102476:	68 f4 00 00 00       	push   $0xf4
  jmp __alltraps
  10247b:	e9 f8 f5 ff ff       	jmp    101a78 <__alltraps>

00102480 <vector245>:
.globl vector245
vector245:
  pushl $0
  102480:	6a 00                	push   $0x0
  pushl $245
  102482:	68 f5 00 00 00       	push   $0xf5
  jmp __alltraps
  102487:	e9 ec f5 ff ff       	jmp    101a78 <__alltraps>

0010248c <vector246>:
.globl vector246
vector246:
  pushl $0
  10248c:	6a 00                	push   $0x0
  pushl $246
  10248e:	68 f6 00 00 00       	push   $0xf6
  jmp __alltraps
  102493:	e9 e0 f5 ff ff       	jmp    101a78 <__alltraps>

00102498 <vector247>:
.globl vector247
vector247:
  pushl $0
  102498:	6a 00                	push   $0x0
  pushl $247
  10249a:	68 f7 00 00 00       	push   $0xf7
  jmp __alltraps
  10249f:	e9 d4 f5 ff ff       	jmp    101a78 <__alltraps>

001024a4 <vector248>:
.globl vector248
vector248:
  pushl $0
  1024a4:	6a 00                	push   $0x0
  pushl $248
  1024a6:	68 f8 00 00 00       	push   $0xf8
  jmp __alltraps
  1024ab:	e9 c8 f5 ff ff       	jmp    101a78 <__alltraps>

001024b0 <vector249>:
.globl vector249
vector249:
  pushl $0
  1024b0:	6a 00                	push   $0x0
  pushl $249
  1024b2:	68 f9 00 00 00       	push   $0xf9
  jmp __alltraps
  1024b7:	e9 bc f5 ff ff       	jmp    101a78 <__alltraps>

001024bc <vector250>:
.globl vector250
vector250:
  pushl $0
  1024bc:	6a 00                	push   $0x0
  pushl $250
  1024be:	68 fa 00 00 00       	push   $0xfa
  jmp __alltraps
  1024c3:	e9 b0 f5 ff ff       	jmp    101a78 <__alltraps>

001024c8 <vector251>:
.globl vector251
vector251:
  pushl $0
  1024c8:	6a 00                	push   $0x0
  pushl $251
  1024ca:	68 fb 00 00 00       	push   $0xfb
  jmp __alltraps
  1024cf:	e9 a4 f5 ff ff       	jmp    101a78 <__alltraps>

001024d4 <vector252>:
.globl vector252
vector252:
  pushl $0
  1024d4:	6a 00                	push   $0x0
  pushl $252
  1024d6:	68 fc 00 00 00       	push   $0xfc
  jmp __alltraps
  1024db:	e9 98 f5 ff ff       	jmp    101a78 <__alltraps>

001024e0 <vector253>:
.globl vector253
vector253:
  pushl $0
  1024e0:	6a 00                	push   $0x0
  pushl $253
  1024e2:	68 fd 00 00 00       	push   $0xfd
  jmp __alltraps
  1024e7:	e9 8c f5 ff ff       	jmp    101a78 <__alltraps>

001024ec <vector254>:
.globl vector254
vector254:
  pushl $0
  1024ec:	6a 00                	push   $0x0
  pushl $254
  1024ee:	68 fe 00 00 00       	push   $0xfe
  jmp __alltraps
  1024f3:	e9 80 f5 ff ff       	jmp    101a78 <__alltraps>

001024f8 <vector255>:
.globl vector255
vector255:
  pushl $0
  1024f8:	6a 00                	push   $0x0
  pushl $255
  1024fa:	68 ff 00 00 00       	push   $0xff
  jmp __alltraps
  1024ff:	e9 74 f5 ff ff       	jmp    101a78 <__alltraps>

00102504 <printnum>:
 * @width: 		maximum number of digits, if the actual width is less than @width, use @padc instead
 * @padc:		character that padded on the left if the actual width is less than @width
 * */
static void
printnum(void (*putch)(int, void*), void *putdat,
		unsigned long long num, unsigned base, int width, int padc) {
  102504:	55                   	push   %ebp
  102505:	89 e5                	mov    %esp,%ebp
  102507:	83 ec 58             	sub    $0x58,%esp
  10250a:	8b 45 10             	mov    0x10(%ebp),%eax
  10250d:	89 45 d0             	mov    %eax,-0x30(%ebp)
  102510:	8b 45 14             	mov    0x14(%ebp),%eax
  102513:	89 45 d4             	mov    %eax,-0x2c(%ebp)
	unsigned long long result = num;
  102516:	8b 45 d0             	mov    -0x30(%ebp),%eax
  102519:	8b 55 d4             	mov    -0x2c(%ebp),%edx
  10251c:	89 45 d8             	mov    %eax,-0x28(%ebp)
  10251f:	89 55 dc             	mov    %edx,-0x24(%ebp)
	unsigned mod = do_div(result, base);
  102522:	8b 45 18             	mov    0x18(%ebp),%eax
  102525:	89 45 f4             	mov    %eax,-0xc(%ebp)
  102528:	8b 45 d8             	mov    -0x28(%ebp),%eax
  10252b:	8b 55 dc             	mov    -0x24(%ebp),%edx
  10252e:	89 45 e8             	mov    %eax,-0x18(%ebp)
  102531:	89 55 ec             	mov    %edx,-0x14(%ebp)
  102534:	8b 45 ec             	mov    -0x14(%ebp),%eax
  102537:	89 45 e4             	mov    %eax,-0x1c(%ebp)
  10253a:	83 7d ec 00          	cmpl   $0x0,-0x14(%ebp)
  10253e:	74 1c                	je     10255c <printnum+0x58>
  102540:	8b 45 ec             	mov    -0x14(%ebp),%eax
  102543:	ba 00 00 00 00       	mov    $0x0,%edx
  102548:	f7 75 f4             	divl   -0xc(%ebp)
  10254b:	89 55 e4             	mov    %edx,-0x1c(%ebp)
  10254e:	8b 45 ec             	mov    -0x14(%ebp),%eax
  102551:	ba 00 00 00 00       	mov    $0x0,%edx
  102556:	f7 75 f4             	divl   -0xc(%ebp)
  102559:	89 45 ec             	mov    %eax,-0x14(%ebp)
  10255c:	8b 45 e8             	mov    -0x18(%ebp),%eax
  10255f:	8b 55 e4             	mov    -0x1c(%ebp),%edx
  102562:	f7 75 f4             	divl   -0xc(%ebp)
  102565:	89 45 e8             	mov    %eax,-0x18(%ebp)
  102568:	89 55 f0             	mov    %edx,-0x10(%ebp)
  10256b:	8b 45 e8             	mov    -0x18(%ebp),%eax
  10256e:	8b 55 ec             	mov    -0x14(%ebp),%edx
  102571:	89 45 d8             	mov    %eax,-0x28(%ebp)
  102574:	89 55 dc             	mov    %edx,-0x24(%ebp)
  102577:	8b 45 f0             	mov    -0x10(%ebp),%eax
  10257a:	89 45 e0             	mov    %eax,-0x20(%ebp)

	// first recursively print all preceding (more significant) digits
	if (num >= base) {
  10257d:	8b 45 18             	mov    0x18(%ebp),%eax
  102580:	ba 00 00 00 00       	mov    $0x0,%edx
  102585:	3b 55 d4             	cmp    -0x2c(%ebp),%edx
  102588:	77 56                	ja     1025e0 <printnum+0xdc>
  10258a:	3b 55 d4             	cmp    -0x2c(%ebp),%edx
  10258d:	72 05                	jb     102594 <printnum+0x90>
  10258f:	3b 45 d0             	cmp    -0x30(%ebp),%eax
  102592:	77 4c                	ja     1025e0 <printnum+0xdc>
		printnum(putch, putdat, result, base, width - 1, padc);
  102594:	8b 45 1c             	mov    0x1c(%ebp),%eax
  102597:	8d 50 ff             	lea    -0x1(%eax),%edx
  10259a:	8b 45 20             	mov    0x20(%ebp),%eax
  10259d:	89 44 24 18          	mov    %eax,0x18(%esp)
  1025a1:	89 54 24 14          	mov    %edx,0x14(%esp)
  1025a5:	8b 45 18             	mov    0x18(%ebp),%eax
  1025a8:	89 44 24 10          	mov    %eax,0x10(%esp)
  1025ac:	8b 45 d8             	mov    -0x28(%ebp),%eax
  1025af:	8b 55 dc             	mov    -0x24(%ebp),%edx
  1025b2:	89 44 24 08          	mov    %eax,0x8(%esp)
  1025b6:	89 54 24 0c          	mov    %edx,0xc(%esp)
  1025ba:	8b 45 0c             	mov    0xc(%ebp),%eax
  1025bd:	89 44 24 04          	mov    %eax,0x4(%esp)
  1025c1:	8b 45 08             	mov    0x8(%ebp),%eax
  1025c4:	89 04 24             	mov    %eax,(%esp)
  1025c7:	e8 38 ff ff ff       	call   102504 <printnum>
  1025cc:	eb 1c                	jmp    1025ea <printnum+0xe6>
	} else {
		// print any needed pad characters before first digit
		while (-- width > 0)
			putch(padc, putdat);
  1025ce:	8b 45 0c             	mov    0xc(%ebp),%eax
  1025d1:	89 44 24 04          	mov    %eax,0x4(%esp)
  1025d5:	8b 45 20             	mov    0x20(%ebp),%eax
  1025d8:	89 04 24             	mov    %eax,(%esp)
  1025db:	8b 45 08             	mov    0x8(%ebp),%eax
  1025de:	ff d0                	call   *%eax
	// first recursively print all preceding (more significant) digits
	if (num >= base) {
		printnum(putch, putdat, result, base, width - 1, padc);
	} else {
		// print any needed pad characters before first digit
		while (-- width > 0)
  1025e0:	83 6d 1c 01          	subl   $0x1,0x1c(%ebp)
  1025e4:	83 7d 1c 00          	cmpl   $0x0,0x1c(%ebp)
  1025e8:	7f e4                	jg     1025ce <printnum+0xca>
			putch(padc, putdat);
	}
	// then print this (the least significant) digit
	putch("0123456789abcdef"[mod], putdat);
  1025ea:	8b 45 e0             	mov    -0x20(%ebp),%eax
  1025ed:	0f b6 80 90 37 10 00 	movzbl 0x103790(%eax),%eax
  1025f4:	0f be c0             	movsbl %al,%eax
  1025f7:	8b 55 0c             	mov    0xc(%ebp),%edx
  1025fa:	89 54 24 04          	mov    %edx,0x4(%esp)
  1025fe:	89 04 24             	mov    %eax,(%esp)
  102601:	8b 45 08             	mov    0x8(%ebp),%eax
  102604:	ff d0                	call   *%eax
}
  102606:	c9                   	leave  
  102607:	c3                   	ret    

00102608 <getuint>:
 * getuint - get an unsigned int of various possible sizes from a varargs list
 * @ap:			a varargs list pointer
 * @lflag:		determines the size of the vararg that @ap points to
 * */
static unsigned long long
getuint(va_list *ap, int lflag) {
  102608:	55                   	push   %ebp
  102609:	89 e5                	mov    %esp,%ebp
	if (lflag >= 2) {
  10260b:	83 7d 0c 01          	cmpl   $0x1,0xc(%ebp)
  10260f:	7e 1c                	jle    10262d <getuint+0x25>
		return va_arg(*ap, unsigned long long);
  102611:	8b 45 08             	mov    0x8(%ebp),%eax
  102614:	8b 00                	mov    (%eax),%eax
  102616:	8d 50 08             	lea    0x8(%eax),%edx
  102619:	8b 45 08             	mov    0x8(%ebp),%eax
  10261c:	89 10                	mov    %edx,(%eax)
  10261e:	8b 45 08             	mov    0x8(%ebp),%eax
  102621:	8b 00                	mov    (%eax),%eax
  102623:	83 e8 08             	sub    $0x8,%eax
  102626:	8b 50 04             	mov    0x4(%eax),%edx
  102629:	8b 00                	mov    (%eax),%eax
  10262b:	eb 40                	jmp    10266d <getuint+0x65>
	}
	else if (lflag) {
  10262d:	83 7d 0c 00          	cmpl   $0x0,0xc(%ebp)
  102631:	74 1e                	je     102651 <getuint+0x49>
		return va_arg(*ap, unsigned long);
  102633:	8b 45 08             	mov    0x8(%ebp),%eax
  102636:	8b 00                	mov    (%eax),%eax
  102638:	8d 50 04             	lea    0x4(%eax),%edx
  10263b:	8b 45 08             	mov    0x8(%ebp),%eax
  10263e:	89 10                	mov    %edx,(%eax)
  102640:	8b 45 08             	mov    0x8(%ebp),%eax
  102643:	8b 00                	mov    (%eax),%eax
  102645:	83 e8 04             	sub    $0x4,%eax
  102648:	8b 00                	mov    (%eax),%eax
  10264a:	ba 00 00 00 00       	mov    $0x0,%edx
  10264f:	eb 1c                	jmp    10266d <getuint+0x65>
	}
	else {
		return va_arg(*ap, unsigned int);
  102651:	8b 45 08             	mov    0x8(%ebp),%eax
  102654:	8b 00                	mov    (%eax),%eax
  102656:	8d 50 04             	lea    0x4(%eax),%edx
  102659:	8b 45 08             	mov    0x8(%ebp),%eax
  10265c:	89 10                	mov    %edx,(%eax)
  10265e:	8b 45 08             	mov    0x8(%ebp),%eax
  102661:	8b 00                	mov    (%eax),%eax
  102663:	83 e8 04             	sub    $0x4,%eax
  102666:	8b 00                	mov    (%eax),%eax
  102668:	ba 00 00 00 00       	mov    $0x0,%edx
	}
}
  10266d:	5d                   	pop    %ebp
  10266e:	c3                   	ret    

0010266f <getint>:
 * getint - same as getuint but signed, we can't use getuint because of sign extension
 * @ap:			a varargs list pointer
 * @lflag:		determines the size of the vararg that @ap points to
 * */
static long long
getint(va_list *ap, int lflag) {
  10266f:	55                   	push   %ebp
  102670:	89 e5                	mov    %esp,%ebp
	if (lflag >= 2) {
  102672:	83 7d 0c 01          	cmpl   $0x1,0xc(%ebp)
  102676:	7e 1c                	jle    102694 <getint+0x25>
		return va_arg(*ap, long long);
  102678:	8b 45 08             	mov    0x8(%ebp),%eax
  10267b:	8b 00                	mov    (%eax),%eax
  10267d:	8d 50 08             	lea    0x8(%eax),%edx
  102680:	8b 45 08             	mov    0x8(%ebp),%eax
  102683:	89 10                	mov    %edx,(%eax)
  102685:	8b 45 08             	mov    0x8(%ebp),%eax
  102688:	8b 00                	mov    (%eax),%eax
  10268a:	83 e8 08             	sub    $0x8,%eax
  10268d:	8b 50 04             	mov    0x4(%eax),%edx
  102690:	8b 00                	mov    (%eax),%eax
  102692:	eb 40                	jmp    1026d4 <getint+0x65>
	}
	else if (lflag) {
  102694:	83 7d 0c 00          	cmpl   $0x0,0xc(%ebp)
  102698:	74 1e                	je     1026b8 <getint+0x49>
		return va_arg(*ap, long);
  10269a:	8b 45 08             	mov    0x8(%ebp),%eax
  10269d:	8b 00                	mov    (%eax),%eax
  10269f:	8d 50 04             	lea    0x4(%eax),%edx
  1026a2:	8b 45 08             	mov    0x8(%ebp),%eax
  1026a5:	89 10                	mov    %edx,(%eax)
  1026a7:	8b 45 08             	mov    0x8(%ebp),%eax
  1026aa:	8b 00                	mov    (%eax),%eax
  1026ac:	83 e8 04             	sub    $0x4,%eax
  1026af:	8b 00                	mov    (%eax),%eax
  1026b1:	89 c2                	mov    %eax,%edx
  1026b3:	c1 fa 1f             	sar    $0x1f,%edx
  1026b6:	eb 1c                	jmp    1026d4 <getint+0x65>
	}
	else {
		return va_arg(*ap, int);
  1026b8:	8b 45 08             	mov    0x8(%ebp),%eax
  1026bb:	8b 00                	mov    (%eax),%eax
  1026bd:	8d 50 04             	lea    0x4(%eax),%edx
  1026c0:	8b 45 08             	mov    0x8(%ebp),%eax
  1026c3:	89 10                	mov    %edx,(%eax)
  1026c5:	8b 45 08             	mov    0x8(%ebp),%eax
  1026c8:	8b 00                	mov    (%eax),%eax
  1026ca:	83 e8 04             	sub    $0x4,%eax
  1026cd:	8b 00                	mov    (%eax),%eax
  1026cf:	89 c2                	mov    %eax,%edx
  1026d1:	c1 fa 1f             	sar    $0x1f,%edx
	}
}
  1026d4:	5d                   	pop    %ebp
  1026d5:	c3                   	ret    

001026d6 <printfmt>:
 * @putch:		specified putch function, print a single character
 * @putdat:		used by @putch function
 * @fmt:		the format string to use
 * */
void
printfmt(void (*putch)(int, void*), void *putdat, const char *fmt, ...) {
  1026d6:	55                   	push   %ebp
  1026d7:	89 e5                	mov    %esp,%ebp
  1026d9:	83 ec 28             	sub    $0x28,%esp
	va_list ap;

	va_start(ap, fmt);
  1026dc:	8d 45 10             	lea    0x10(%ebp),%eax
  1026df:	83 c0 04             	add    $0x4,%eax
  1026e2:	89 45 f4             	mov    %eax,-0xc(%ebp)
	vprintfmt(putch, putdat, fmt, ap);
  1026e5:	8b 45 10             	mov    0x10(%ebp),%eax
  1026e8:	8b 55 f4             	mov    -0xc(%ebp),%edx
  1026eb:	89 54 24 0c          	mov    %edx,0xc(%esp)
  1026ef:	89 44 24 08          	mov    %eax,0x8(%esp)
  1026f3:	8b 45 0c             	mov    0xc(%ebp),%eax
  1026f6:	89 44 24 04          	mov    %eax,0x4(%esp)
  1026fa:	8b 45 08             	mov    0x8(%ebp),%eax
  1026fd:	89 04 24             	mov    %eax,(%esp)
  102700:	e8 02 00 00 00       	call   102707 <vprintfmt>
	va_end(ap);
}
  102705:	c9                   	leave  
  102706:	c3                   	ret    

00102707 <vprintfmt>:
 *
 * Call this function if you are already dealing with a va_list.
 * Or you probably want printfmt() instead.
 * */
void
vprintfmt(void (*putch)(int, void*), void *putdat, const char *fmt, va_list ap) {
  102707:	55                   	push   %ebp
  102708:	89 e5                	mov    %esp,%ebp
  10270a:	56                   	push   %esi
  10270b:	53                   	push   %ebx
  10270c:	83 ec 40             	sub    $0x40,%esp
	register int ch, err;
	unsigned long long num;
	int base, width, precision, lflag, altflag;

	while (1) {
		while ((ch = *(unsigned char *)fmt ++) != '%') {
  10270f:	eb 17                	jmp    102728 <vprintfmt+0x21>
			if (ch == '\0') {
  102711:	85 db                	test   %ebx,%ebx
  102713:	0f 84 06 04 00 00    	je     102b1f <vprintfmt+0x418>
				return;
			}
			putch(ch, putdat);
  102719:	8b 45 0c             	mov    0xc(%ebp),%eax
  10271c:	89 44 24 04          	mov    %eax,0x4(%esp)
  102720:	89 1c 24             	mov    %ebx,(%esp)
  102723:	8b 45 08             	mov    0x8(%ebp),%eax
  102726:	ff d0                	call   *%eax
	register int ch, err;
	unsigned long long num;
	int base, width, precision, lflag, altflag;

	while (1) {
		while ((ch = *(unsigned char *)fmt ++) != '%') {
  102728:	8b 45 10             	mov    0x10(%ebp),%eax
  10272b:	0f b6 00             	movzbl (%eax),%eax
  10272e:	0f b6 d8             	movzbl %al,%ebx
  102731:	83 fb 25             	cmp    $0x25,%ebx
  102734:	0f 95 c0             	setne  %al
  102737:	83 45 10 01          	addl   $0x1,0x10(%ebp)
  10273b:	84 c0                	test   %al,%al
  10273d:	75 d2                	jne    102711 <vprintfmt+0xa>
			}
			putch(ch, putdat);
		}

		// Process a %-escape sequence
		char padc = ' ';
  10273f:	c6 45 f7 20          	movb   $0x20,-0x9(%ebp)
		width = precision = -1;
  102743:	c7 45 e8 ff ff ff ff 	movl   $0xffffffff,-0x18(%ebp)
  10274a:	8b 45 e8             	mov    -0x18(%ebp),%eax
  10274d:	89 45 e4             	mov    %eax,-0x1c(%ebp)
		lflag = altflag = 0;
  102750:	c7 45 f0 00 00 00 00 	movl   $0x0,-0x10(%ebp)
  102757:	8b 45 f0             	mov    -0x10(%ebp),%eax
  10275a:	89 45 ec             	mov    %eax,-0x14(%ebp)
  10275d:	eb 04                	jmp    102763 <vprintfmt+0x5c>
			goto process_precision;

		case '.':
			if (width < 0)
				width = 0;
			goto reswitch;
  10275f:	90                   	nop
  102760:	eb 01                	jmp    102763 <vprintfmt+0x5c>
			goto reswitch;

		process_precision:
			if (width < 0)
				width = precision, precision = -1;
			goto reswitch;
  102762:	90                   	nop
		char padc = ' ';
		width = precision = -1;
		lflag = altflag = 0;

	reswitch:
		switch (ch = *(unsigned char *)fmt ++) {
  102763:	8b 45 10             	mov    0x10(%ebp),%eax
  102766:	0f b6 00             	movzbl (%eax),%eax
  102769:	0f b6 d8             	movzbl %al,%ebx
  10276c:	89 d8                	mov    %ebx,%eax
  10276e:	83 45 10 01          	addl   $0x1,0x10(%ebp)
  102772:	83 e8 23             	sub    $0x23,%eax
  102775:	83 f8 55             	cmp    $0x55,%eax
  102778:	0f 87 71 03 00 00    	ja     102aef <vprintfmt+0x3e8>
  10277e:	8b 04 85 b4 37 10 00 	mov    0x1037b4(,%eax,4),%eax
  102785:	ff e0                	jmp    *%eax

		// flag to pad on the right
		case '-':
			padc = '-';
  102787:	c6 45 f7 2d          	movb   $0x2d,-0x9(%ebp)
			goto reswitch;
  10278b:	eb d6                	jmp    102763 <vprintfmt+0x5c>

		// flag to pad with 0's instead of spaces
		case '0':
			padc = '0';
  10278d:	c6 45 f7 30          	movb   $0x30,-0x9(%ebp)
			goto reswitch;
  102791:	eb d0                	jmp    102763 <vprintfmt+0x5c>

		// width field
		case '1' ... '9':
			for (precision = 0; ; ++ fmt) {
  102793:	c7 45 e8 00 00 00 00 	movl   $0x0,-0x18(%ebp)
				precision = precision * 10 + ch - '0';
  10279a:	8b 55 e8             	mov    -0x18(%ebp),%edx
  10279d:	89 d0                	mov    %edx,%eax
  10279f:	c1 e0 02             	shl    $0x2,%eax
  1027a2:	01 d0                	add    %edx,%eax
  1027a4:	01 c0                	add    %eax,%eax
  1027a6:	01 d8                	add    %ebx,%eax
  1027a8:	83 e8 30             	sub    $0x30,%eax
  1027ab:	89 45 e8             	mov    %eax,-0x18(%ebp)
				ch = *fmt;
  1027ae:	8b 45 10             	mov    0x10(%ebp),%eax
  1027b1:	0f b6 00             	movzbl (%eax),%eax
  1027b4:	0f be d8             	movsbl %al,%ebx
				if (ch < '0' || ch > '9') {
  1027b7:	83 fb 2f             	cmp    $0x2f,%ebx
  1027ba:	7e 43                	jle    1027ff <vprintfmt+0xf8>
  1027bc:	83 fb 39             	cmp    $0x39,%ebx
  1027bf:	7f 41                	jg     102802 <vprintfmt+0xfb>
			padc = '0';
			goto reswitch;

		// width field
		case '1' ... '9':
			for (precision = 0; ; ++ fmt) {
  1027c1:	83 45 10 01          	addl   $0x1,0x10(%ebp)
				precision = precision * 10 + ch - '0';
				ch = *fmt;
				if (ch < '0' || ch > '9') {
					break;
				}
			}
  1027c5:	eb d3                	jmp    10279a <vprintfmt+0x93>
			goto process_precision;

		case '*':
			precision = va_arg(ap, int);
  1027c7:	8b 45 14             	mov    0x14(%ebp),%eax
  1027ca:	83 c0 04             	add    $0x4,%eax
  1027cd:	89 45 14             	mov    %eax,0x14(%ebp)
  1027d0:	8b 45 14             	mov    0x14(%ebp),%eax
  1027d3:	83 e8 04             	sub    $0x4,%eax
  1027d6:	8b 00                	mov    (%eax),%eax
  1027d8:	89 45 e8             	mov    %eax,-0x18(%ebp)
			goto process_precision;
  1027db:	eb 26                	jmp    102803 <vprintfmt+0xfc>

		case '.':
			if (width < 0)
  1027dd:	83 7d e4 00          	cmpl   $0x0,-0x1c(%ebp)
  1027e1:	0f 89 78 ff ff ff    	jns    10275f <vprintfmt+0x58>
				width = 0;
  1027e7:	c7 45 e4 00 00 00 00 	movl   $0x0,-0x1c(%ebp)
			goto reswitch;
  1027ee:	e9 70 ff ff ff       	jmp    102763 <vprintfmt+0x5c>

		case '#':
			altflag = 1;
  1027f3:	c7 45 f0 01 00 00 00 	movl   $0x1,-0x10(%ebp)
			goto reswitch;
  1027fa:	e9 64 ff ff ff       	jmp    102763 <vprintfmt+0x5c>
				ch = *fmt;
				if (ch < '0' || ch > '9') {
					break;
				}
			}
			goto process_precision;
  1027ff:	90                   	nop
  102800:	eb 01                	jmp    102803 <vprintfmt+0xfc>
  102802:	90                   	nop
		case '#':
			altflag = 1;
			goto reswitch;

		process_precision:
			if (width < 0)
  102803:	83 7d e4 00          	cmpl   $0x0,-0x1c(%ebp)
  102807:	0f 89 55 ff ff ff    	jns    102762 <vprintfmt+0x5b>
				width = precision, precision = -1;
  10280d:	8b 45 e8             	mov    -0x18(%ebp),%eax
  102810:	89 45 e4             	mov    %eax,-0x1c(%ebp)
  102813:	c7 45 e8 ff ff ff ff 	movl   $0xffffffff,-0x18(%ebp)
			goto reswitch;
  10281a:	e9 44 ff ff ff       	jmp    102763 <vprintfmt+0x5c>

		// long flag (doubled for long long)
		case 'l':
			lflag ++;
  10281f:	83 45 ec 01          	addl   $0x1,-0x14(%ebp)
			goto reswitch;
  102823:	e9 3b ff ff ff       	jmp    102763 <vprintfmt+0x5c>

		// character
		case 'c':
			putch(va_arg(ap, int), putdat);
  102828:	8b 45 14             	mov    0x14(%ebp),%eax
  10282b:	83 c0 04             	add    $0x4,%eax
  10282e:	89 45 14             	mov    %eax,0x14(%ebp)
  102831:	8b 45 14             	mov    0x14(%ebp),%eax
  102834:	83 e8 04             	sub    $0x4,%eax
  102837:	8b 00                	mov    (%eax),%eax
  102839:	8b 55 0c             	mov    0xc(%ebp),%edx
  10283c:	89 54 24 04          	mov    %edx,0x4(%esp)
  102840:	89 04 24             	mov    %eax,(%esp)
  102843:	8b 45 08             	mov    0x8(%ebp),%eax
  102846:	ff d0                	call   *%eax
			break;
  102848:	e9 cc 02 00 00       	jmp    102b19 <vprintfmt+0x412>

		// error message
		case 'e':
			err = va_arg(ap, int);
  10284d:	8b 45 14             	mov    0x14(%ebp),%eax
  102850:	83 c0 04             	add    $0x4,%eax
  102853:	89 45 14             	mov    %eax,0x14(%ebp)
  102856:	8b 45 14             	mov    0x14(%ebp),%eax
  102859:	83 e8 04             	sub    $0x4,%eax
  10285c:	8b 18                	mov    (%eax),%ebx
			if (err < 0) {
  10285e:	85 db                	test   %ebx,%ebx
  102860:	79 02                	jns    102864 <vprintfmt+0x15d>
				err = -err;
  102862:	f7 db                	neg    %ebx
			}
			if (err > MAXERROR || (p = error_string[err]) == NULL) {
  102864:	83 fb 06             	cmp    $0x6,%ebx
  102867:	7f 0d                	jg     102876 <vprintfmt+0x16f>
  102869:	89 d8                	mov    %ebx,%eax
  10286b:	8b 34 85 74 37 10 00 	mov    0x103774(,%eax,4),%esi
  102872:	85 f6                	test   %esi,%esi
  102874:	75 24                	jne    10289a <vprintfmt+0x193>
				printfmt(putch, putdat, "error %d", err);
  102876:	89 5c 24 0c          	mov    %ebx,0xc(%esp)
  10287a:	c7 44 24 08 a1 37 10 	movl   $0x1037a1,0x8(%esp)
  102881:	00 
  102882:	8b 45 0c             	mov    0xc(%ebp),%eax
  102885:	89 44 24 04          	mov    %eax,0x4(%esp)
  102889:	8b 45 08             	mov    0x8(%ebp),%eax
  10288c:	89 04 24             	mov    %eax,(%esp)
  10288f:	e8 42 fe ff ff       	call   1026d6 <printfmt>
		case 'e':
			err = va_arg(ap, int);
			if (err < 0) {
				err = -err;
			}
			if (err > MAXERROR || (p = error_string[err]) == NULL) {
  102894:	90                   	nop
				printfmt(putch, putdat, "error %d", err);
			}
			else {
				printfmt(putch, putdat, "%s", p);
			}
			break;
  102895:	e9 7f 02 00 00       	jmp    102b19 <vprintfmt+0x412>
			}
			if (err > MAXERROR || (p = error_string[err]) == NULL) {
				printfmt(putch, putdat, "error %d", err);
			}
			else {
				printfmt(putch, putdat, "%s", p);
  10289a:	89 74 24 0c          	mov    %esi,0xc(%esp)
  10289e:	c7 44 24 08 aa 37 10 	movl   $0x1037aa,0x8(%esp)
  1028a5:	00 
  1028a6:	8b 45 0c             	mov    0xc(%ebp),%eax
  1028a9:	89 44 24 04          	mov    %eax,0x4(%esp)
  1028ad:	8b 45 08             	mov    0x8(%ebp),%eax
  1028b0:	89 04 24             	mov    %eax,(%esp)
  1028b3:	e8 1e fe ff ff       	call   1026d6 <printfmt>
			}
			break;
  1028b8:	e9 5c 02 00 00       	jmp    102b19 <vprintfmt+0x412>

		// string
		case 's':
			if ((p = va_arg(ap, char *)) == NULL) {
  1028bd:	8b 45 14             	mov    0x14(%ebp),%eax
  1028c0:	83 c0 04             	add    $0x4,%eax
  1028c3:	89 45 14             	mov    %eax,0x14(%ebp)
  1028c6:	8b 45 14             	mov    0x14(%ebp),%eax
  1028c9:	83 e8 04             	sub    $0x4,%eax
  1028cc:	8b 30                	mov    (%eax),%esi
  1028ce:	85 f6                	test   %esi,%esi
  1028d0:	75 05                	jne    1028d7 <vprintfmt+0x1d0>
				p = "(null)";
  1028d2:	be ad 37 10 00       	mov    $0x1037ad,%esi
			}
			if (width > 0 && padc != '-') {
  1028d7:	83 7d e4 00          	cmpl   $0x0,-0x1c(%ebp)
  1028db:	7e 7c                	jle    102959 <vprintfmt+0x252>
  1028dd:	80 7d f7 2d          	cmpb   $0x2d,-0x9(%ebp)
  1028e1:	74 79                	je     10295c <vprintfmt+0x255>
				for (width -= strnlen(p, precision); width > 0; width --) {
  1028e3:	8b 5d e4             	mov    -0x1c(%ebp),%ebx
  1028e6:	8b 45 e8             	mov    -0x18(%ebp),%eax
  1028e9:	89 44 24 04          	mov    %eax,0x4(%esp)
  1028ed:	89 34 24             	mov    %esi,(%esp)
  1028f0:	e8 2e 03 00 00       	call   102c23 <strnlen>
  1028f5:	89 da                	mov    %ebx,%edx
  1028f7:	29 c2                	sub    %eax,%edx
  1028f9:	89 d0                	mov    %edx,%eax
  1028fb:	89 45 e4             	mov    %eax,-0x1c(%ebp)
  1028fe:	eb 17                	jmp    102917 <vprintfmt+0x210>
					putch(padc, putdat);
  102900:	0f be 45 f7          	movsbl -0x9(%ebp),%eax
  102904:	8b 55 0c             	mov    0xc(%ebp),%edx
  102907:	89 54 24 04          	mov    %edx,0x4(%esp)
  10290b:	89 04 24             	mov    %eax,(%esp)
  10290e:	8b 45 08             	mov    0x8(%ebp),%eax
  102911:	ff d0                	call   *%eax
		case 's':
			if ((p = va_arg(ap, char *)) == NULL) {
				p = "(null)";
			}
			if (width > 0 && padc != '-') {
				for (width -= strnlen(p, precision); width > 0; width --) {
  102913:	83 6d e4 01          	subl   $0x1,-0x1c(%ebp)
  102917:	83 7d e4 00          	cmpl   $0x0,-0x1c(%ebp)
  10291b:	7f e3                	jg     102900 <vprintfmt+0x1f9>
					putch(padc, putdat);
				}
			}
			for (; (ch = *p ++) != '\0' && (precision < 0 || -- precision >= 0); width --) {
  10291d:	eb 3e                	jmp    10295d <vprintfmt+0x256>
				if (altflag && (ch < ' ' || ch > '~')) {
  10291f:	83 7d f0 00          	cmpl   $0x0,-0x10(%ebp)
  102923:	74 1f                	je     102944 <vprintfmt+0x23d>
  102925:	83 fb 1f             	cmp    $0x1f,%ebx
  102928:	7e 05                	jle    10292f <vprintfmt+0x228>
  10292a:	83 fb 7e             	cmp    $0x7e,%ebx
  10292d:	7e 15                	jle    102944 <vprintfmt+0x23d>
					putch('?', putdat);
  10292f:	8b 45 0c             	mov    0xc(%ebp),%eax
  102932:	89 44 24 04          	mov    %eax,0x4(%esp)
  102936:	c7 04 24 3f 00 00 00 	movl   $0x3f,(%esp)
  10293d:	8b 45 08             	mov    0x8(%ebp),%eax
  102940:	ff d0                	call   *%eax
				for (width -= strnlen(p, precision); width > 0; width --) {
					putch(padc, putdat);
				}
			}
			for (; (ch = *p ++) != '\0' && (precision < 0 || -- precision >= 0); width --) {
				if (altflag && (ch < ' ' || ch > '~')) {
  102942:	eb 0f                	jmp    102953 <vprintfmt+0x24c>
					putch('?', putdat);
				}
				else {
					putch(ch, putdat);
  102944:	8b 45 0c             	mov    0xc(%ebp),%eax
  102947:	89 44 24 04          	mov    %eax,0x4(%esp)
  10294b:	89 1c 24             	mov    %ebx,(%esp)
  10294e:	8b 45 08             	mov    0x8(%ebp),%eax
  102951:	ff d0                	call   *%eax
			if (width > 0 && padc != '-') {
				for (width -= strnlen(p, precision); width > 0; width --) {
					putch(padc, putdat);
				}
			}
			for (; (ch = *p ++) != '\0' && (precision < 0 || -- precision >= 0); width --) {
  102953:	83 6d e4 01          	subl   $0x1,-0x1c(%ebp)
  102957:	eb 04                	jmp    10295d <vprintfmt+0x256>
  102959:	90                   	nop
  10295a:	eb 01                	jmp    10295d <vprintfmt+0x256>
  10295c:	90                   	nop
  10295d:	0f b6 06             	movzbl (%esi),%eax
  102960:	0f be d8             	movsbl %al,%ebx
  102963:	85 db                	test   %ebx,%ebx
  102965:	0f 95 c0             	setne  %al
  102968:	83 c6 01             	add    $0x1,%esi
  10296b:	84 c0                	test   %al,%al
  10296d:	74 29                	je     102998 <vprintfmt+0x291>
  10296f:	83 7d e8 00          	cmpl   $0x0,-0x18(%ebp)
  102973:	78 aa                	js     10291f <vprintfmt+0x218>
  102975:	83 6d e8 01          	subl   $0x1,-0x18(%ebp)
  102979:	83 7d e8 00          	cmpl   $0x0,-0x18(%ebp)
  10297d:	79 a0                	jns    10291f <vprintfmt+0x218>
				}
				else {
					putch(ch, putdat);
				}
			}
			for (; width > 0; width --) {
  10297f:	eb 17                	jmp    102998 <vprintfmt+0x291>
				putch(' ', putdat);
  102981:	8b 45 0c             	mov    0xc(%ebp),%eax
  102984:	89 44 24 04          	mov    %eax,0x4(%esp)
  102988:	c7 04 24 20 00 00 00 	movl   $0x20,(%esp)
  10298f:	8b 45 08             	mov    0x8(%ebp),%eax
  102992:	ff d0                	call   *%eax
				}
				else {
					putch(ch, putdat);
				}
			}
			for (; width > 0; width --) {
  102994:	83 6d e4 01          	subl   $0x1,-0x1c(%ebp)
  102998:	83 7d e4 00          	cmpl   $0x0,-0x1c(%ebp)
  10299c:	7f e3                	jg     102981 <vprintfmt+0x27a>
				putch(' ', putdat);
			}
			break;
  10299e:	e9 76 01 00 00       	jmp    102b19 <vprintfmt+0x412>

		// (signed) decimal
		case 'd':
			num = getint(&ap, lflag);
  1029a3:	8b 45 ec             	mov    -0x14(%ebp),%eax
  1029a6:	89 44 24 04          	mov    %eax,0x4(%esp)
  1029aa:	8d 45 14             	lea    0x14(%ebp),%eax
  1029ad:	89 04 24             	mov    %eax,(%esp)
  1029b0:	e8 ba fc ff ff       	call   10266f <getint>
  1029b5:	89 45 d8             	mov    %eax,-0x28(%ebp)
  1029b8:	89 55 dc             	mov    %edx,-0x24(%ebp)
			if ((long long)num < 0) {
  1029bb:	8b 45 d8             	mov    -0x28(%ebp),%eax
  1029be:	8b 55 dc             	mov    -0x24(%ebp),%edx
  1029c1:	85 d2                	test   %edx,%edx
  1029c3:	79 26                	jns    1029eb <vprintfmt+0x2e4>
				putch('-', putdat);
  1029c5:	8b 45 0c             	mov    0xc(%ebp),%eax
  1029c8:	89 44 24 04          	mov    %eax,0x4(%esp)
  1029cc:	c7 04 24 2d 00 00 00 	movl   $0x2d,(%esp)
  1029d3:	8b 45 08             	mov    0x8(%ebp),%eax
  1029d6:	ff d0                	call   *%eax
				num = -(long long)num;
  1029d8:	8b 45 d8             	mov    -0x28(%ebp),%eax
  1029db:	8b 55 dc             	mov    -0x24(%ebp),%edx
  1029de:	f7 d8                	neg    %eax
  1029e0:	83 d2 00             	adc    $0x0,%edx
  1029e3:	f7 da                	neg    %edx
  1029e5:	89 45 d8             	mov    %eax,-0x28(%ebp)
  1029e8:	89 55 dc             	mov    %edx,-0x24(%ebp)
			}
			base = 10;
  1029eb:	c7 45 e0 0a 00 00 00 	movl   $0xa,-0x20(%ebp)
			goto number;
  1029f2:	e9 af 00 00 00       	jmp    102aa6 <vprintfmt+0x39f>

		// unsigned decimal
		case 'u':
			num = getuint(&ap, lflag);
  1029f7:	8b 45 ec             	mov    -0x14(%ebp),%eax
  1029fa:	89 44 24 04          	mov    %eax,0x4(%esp)
  1029fe:	8d 45 14             	lea    0x14(%ebp),%eax
  102a01:	89 04 24             	mov    %eax,(%esp)
  102a04:	e8 ff fb ff ff       	call   102608 <getuint>
  102a09:	89 45 d8             	mov    %eax,-0x28(%ebp)
  102a0c:	89 55 dc             	mov    %edx,-0x24(%ebp)
			base = 10;
  102a0f:	c7 45 e0 0a 00 00 00 	movl   $0xa,-0x20(%ebp)
			goto number;
  102a16:	e9 8b 00 00 00       	jmp    102aa6 <vprintfmt+0x39f>

		// (unsigned) octal
		case 'o':
			num = getuint(&ap, lflag);
  102a1b:	8b 45 ec             	mov    -0x14(%ebp),%eax
  102a1e:	89 44 24 04          	mov    %eax,0x4(%esp)
  102a22:	8d 45 14             	lea    0x14(%ebp),%eax
  102a25:	89 04 24             	mov    %eax,(%esp)
  102a28:	e8 db fb ff ff       	call   102608 <getuint>
  102a2d:	89 45 d8             	mov    %eax,-0x28(%ebp)
  102a30:	89 55 dc             	mov    %edx,-0x24(%ebp)
			base = 8;
  102a33:	c7 45 e0 08 00 00 00 	movl   $0x8,-0x20(%ebp)
			goto number;
  102a3a:	eb 6a                	jmp    102aa6 <vprintfmt+0x39f>

		// pointer
		case 'p':
			putch('0', putdat);
  102a3c:	8b 45 0c             	mov    0xc(%ebp),%eax
  102a3f:	89 44 24 04          	mov    %eax,0x4(%esp)
  102a43:	c7 04 24 30 00 00 00 	movl   $0x30,(%esp)
  102a4a:	8b 45 08             	mov    0x8(%ebp),%eax
  102a4d:	ff d0                	call   *%eax
			putch('x', putdat);
  102a4f:	8b 45 0c             	mov    0xc(%ebp),%eax
  102a52:	89 44 24 04          	mov    %eax,0x4(%esp)
  102a56:	c7 04 24 78 00 00 00 	movl   $0x78,(%esp)
  102a5d:	8b 45 08             	mov    0x8(%ebp),%eax
  102a60:	ff d0                	call   *%eax
			num = (unsigned long long)(uintptr_t)va_arg(ap, void *);
  102a62:	8b 45 14             	mov    0x14(%ebp),%eax
  102a65:	83 c0 04             	add    $0x4,%eax
  102a68:	89 45 14             	mov    %eax,0x14(%ebp)
  102a6b:	8b 45 14             	mov    0x14(%ebp),%eax
  102a6e:	83 e8 04             	sub    $0x4,%eax
  102a71:	8b 00                	mov    (%eax),%eax
  102a73:	ba 00 00 00 00       	mov    $0x0,%edx
  102a78:	89 45 d8             	mov    %eax,-0x28(%ebp)
  102a7b:	89 55 dc             	mov    %edx,-0x24(%ebp)
			base = 16;
  102a7e:	c7 45 e0 10 00 00 00 	movl   $0x10,-0x20(%ebp)
			goto number;
  102a85:	eb 1f                	jmp    102aa6 <vprintfmt+0x39f>

		// (unsigned) hexadecimal
		case 'x':
			num = getuint(&ap, lflag);
  102a87:	8b 45 ec             	mov    -0x14(%ebp),%eax
  102a8a:	89 44 24 04          	mov    %eax,0x4(%esp)
  102a8e:	8d 45 14             	lea    0x14(%ebp),%eax
  102a91:	89 04 24             	mov    %eax,(%esp)
  102a94:	e8 6f fb ff ff       	call   102608 <getuint>
  102a99:	89 45 d8             	mov    %eax,-0x28(%ebp)
  102a9c:	89 55 dc             	mov    %edx,-0x24(%ebp)
			base = 16;
  102a9f:	c7 45 e0 10 00 00 00 	movl   $0x10,-0x20(%ebp)
		number:
			printnum(putch, putdat, num, base, width, padc);
  102aa6:	0f be 55 f7          	movsbl -0x9(%ebp),%edx
  102aaa:	8b 45 e0             	mov    -0x20(%ebp),%eax
  102aad:	89 54 24 18          	mov    %edx,0x18(%esp)
  102ab1:	8b 55 e4             	mov    -0x1c(%ebp),%edx
  102ab4:	89 54 24 14          	mov    %edx,0x14(%esp)
  102ab8:	89 44 24 10          	mov    %eax,0x10(%esp)
  102abc:	8b 45 d8             	mov    -0x28(%ebp),%eax
  102abf:	8b 55 dc             	mov    -0x24(%ebp),%edx
  102ac2:	89 44 24 08          	mov    %eax,0x8(%esp)
  102ac6:	89 54 24 0c          	mov    %edx,0xc(%esp)
  102aca:	8b 45 0c             	mov    0xc(%ebp),%eax
  102acd:	89 44 24 04          	mov    %eax,0x4(%esp)
  102ad1:	8b 45 08             	mov    0x8(%ebp),%eax
  102ad4:	89 04 24             	mov    %eax,(%esp)
  102ad7:	e8 28 fa ff ff       	call   102504 <printnum>
			break;
  102adc:	eb 3b                	jmp    102b19 <vprintfmt+0x412>

		// escaped '%' character
		case '%':
			putch(ch, putdat);
  102ade:	8b 45 0c             	mov    0xc(%ebp),%eax
  102ae1:	89 44 24 04          	mov    %eax,0x4(%esp)
  102ae5:	89 1c 24             	mov    %ebx,(%esp)
  102ae8:	8b 45 08             	mov    0x8(%ebp),%eax
  102aeb:	ff d0                	call   *%eax
			break;
  102aed:	eb 2a                	jmp    102b19 <vprintfmt+0x412>

		// unrecognized escape sequence - just print it literally
		default:
			putch('%', putdat);
  102aef:	8b 45 0c             	mov    0xc(%ebp),%eax
  102af2:	89 44 24 04          	mov    %eax,0x4(%esp)
  102af6:	c7 04 24 25 00 00 00 	movl   $0x25,(%esp)
  102afd:	8b 45 08             	mov    0x8(%ebp),%eax
  102b00:	ff d0                	call   *%eax
			for (fmt --; fmt[-1] != '%'; fmt --)
  102b02:	83 6d 10 01          	subl   $0x1,0x10(%ebp)
  102b06:	eb 04                	jmp    102b0c <vprintfmt+0x405>
  102b08:	83 6d 10 01          	subl   $0x1,0x10(%ebp)
  102b0c:	8b 45 10             	mov    0x10(%ebp),%eax
  102b0f:	83 e8 01             	sub    $0x1,%eax
  102b12:	0f b6 00             	movzbl (%eax),%eax
  102b15:	3c 25                	cmp    $0x25,%al
  102b17:	75 ef                	jne    102b08 <vprintfmt+0x401>
				/* do nothing */;
			break;
		}
	}
  102b19:	90                   	nop
	register int ch, err;
	unsigned long long num;
	int base, width, precision, lflag, altflag;

	while (1) {
		while ((ch = *(unsigned char *)fmt ++) != '%') {
  102b1a:	e9 09 fc ff ff       	jmp    102728 <vprintfmt+0x21>
			for (fmt --; fmt[-1] != '%'; fmt --)
				/* do nothing */;
			break;
		}
	}
}
  102b1f:	83 c4 40             	add    $0x40,%esp
  102b22:	5b                   	pop    %ebx
  102b23:	5e                   	pop    %esi
  102b24:	5d                   	pop    %ebp
  102b25:	c3                   	ret    

00102b26 <sprintputch>:
 * sprintputch - 'print' a single character in a buffer
 * @ch:			the character will be printed
 * @b:			the buffer to place the character @ch
 * */
static void
sprintputch(int ch, struct sprintbuf *b) {
  102b26:	55                   	push   %ebp
  102b27:	89 e5                	mov    %esp,%ebp
	b->cnt ++;
  102b29:	8b 45 0c             	mov    0xc(%ebp),%eax
  102b2c:	8b 40 08             	mov    0x8(%eax),%eax
  102b2f:	8d 50 01             	lea    0x1(%eax),%edx
  102b32:	8b 45 0c             	mov    0xc(%ebp),%eax
  102b35:	89 50 08             	mov    %edx,0x8(%eax)
	if (b->buf < b->ebuf) {
  102b38:	8b 45 0c             	mov    0xc(%ebp),%eax
  102b3b:	8b 10                	mov    (%eax),%edx
  102b3d:	8b 45 0c             	mov    0xc(%ebp),%eax
  102b40:	8b 40 04             	mov    0x4(%eax),%eax
  102b43:	39 c2                	cmp    %eax,%edx
  102b45:	73 12                	jae    102b59 <sprintputch+0x33>
		*b->buf ++ = ch;
  102b47:	8b 45 0c             	mov    0xc(%ebp),%eax
  102b4a:	8b 00                	mov    (%eax),%eax
  102b4c:	8b 55 08             	mov    0x8(%ebp),%edx
  102b4f:	88 10                	mov    %dl,(%eax)
  102b51:	8d 50 01             	lea    0x1(%eax),%edx
  102b54:	8b 45 0c             	mov    0xc(%ebp),%eax
  102b57:	89 10                	mov    %edx,(%eax)
	}
}
  102b59:	5d                   	pop    %ebp
  102b5a:	c3                   	ret    

00102b5b <snprintf>:
 * @str:		the buffer to place the result into
 * @size:		the size of buffer, including the trailing null space
 * @fmt:		the format string to use
 * */
int
snprintf(char *str, size_t size, const char *fmt, ...) {
  102b5b:	55                   	push   %ebp
  102b5c:	89 e5                	mov    %esp,%ebp
  102b5e:	83 ec 28             	sub    $0x28,%esp
	va_list ap;
	int cnt;
	va_start(ap, fmt);
  102b61:	8d 45 10             	lea    0x10(%ebp),%eax
  102b64:	83 c0 04             	add    $0x4,%eax
  102b67:	89 45 f0             	mov    %eax,-0x10(%ebp)
	cnt = vsnprintf(str, size, fmt, ap);
  102b6a:	8b 45 10             	mov    0x10(%ebp),%eax
  102b6d:	8b 55 f0             	mov    -0x10(%ebp),%edx
  102b70:	89 54 24 0c          	mov    %edx,0xc(%esp)
  102b74:	89 44 24 08          	mov    %eax,0x8(%esp)
  102b78:	8b 45 0c             	mov    0xc(%ebp),%eax
  102b7b:	89 44 24 04          	mov    %eax,0x4(%esp)
  102b7f:	8b 45 08             	mov    0x8(%ebp),%eax
  102b82:	89 04 24             	mov    %eax,(%esp)
  102b85:	e8 08 00 00 00       	call   102b92 <vsnprintf>
  102b8a:	89 45 f4             	mov    %eax,-0xc(%ebp)
	va_end(ap);
	return cnt;
  102b8d:	8b 45 f4             	mov    -0xc(%ebp),%eax
}
  102b90:	c9                   	leave  
  102b91:	c3                   	ret    

00102b92 <vsnprintf>:
 *
 * Call this function if you are already dealing with a va_list.
 * Or you probably want snprintf() instead.
 * */
int
vsnprintf(char *str, size_t size, const char *fmt, va_list ap) {
  102b92:	55                   	push   %ebp
  102b93:	89 e5                	mov    %esp,%ebp
  102b95:	83 ec 28             	sub    $0x28,%esp
	struct sprintbuf b = {str, str + size - 1, 0};
  102b98:	8b 45 0c             	mov    0xc(%ebp),%eax
  102b9b:	83 e8 01             	sub    $0x1,%eax
  102b9e:	03 45 08             	add    0x8(%ebp),%eax
  102ba1:	8b 55 08             	mov    0x8(%ebp),%edx
  102ba4:	89 55 ec             	mov    %edx,-0x14(%ebp)
  102ba7:	89 45 f0             	mov    %eax,-0x10(%ebp)
  102baa:	c7 45 f4 00 00 00 00 	movl   $0x0,-0xc(%ebp)
	if (str == NULL || b.buf > b.ebuf) {
  102bb1:	83 7d 08 00          	cmpl   $0x0,0x8(%ebp)
  102bb5:	74 0a                	je     102bc1 <vsnprintf+0x2f>
  102bb7:	8b 55 ec             	mov    -0x14(%ebp),%edx
  102bba:	8b 45 f0             	mov    -0x10(%ebp),%eax
  102bbd:	39 c2                	cmp    %eax,%edx
  102bbf:	76 07                	jbe    102bc8 <vsnprintf+0x36>
		return -E_INVAL;
  102bc1:	b8 fd ff ff ff       	mov    $0xfffffffd,%eax
  102bc6:	eb 2b                	jmp    102bf3 <vsnprintf+0x61>
	}
	// print the string to the buffer
	vprintfmt((void*)sprintputch, &b, fmt, ap);
  102bc8:	b8 26 2b 10 00       	mov    $0x102b26,%eax
  102bcd:	8b 55 14             	mov    0x14(%ebp),%edx
  102bd0:	89 54 24 0c          	mov    %edx,0xc(%esp)
  102bd4:	8b 55 10             	mov    0x10(%ebp),%edx
  102bd7:	89 54 24 08          	mov    %edx,0x8(%esp)
  102bdb:	8d 55 ec             	lea    -0x14(%ebp),%edx
  102bde:	89 54 24 04          	mov    %edx,0x4(%esp)
  102be2:	89 04 24             	mov    %eax,(%esp)
  102be5:	e8 1d fb ff ff       	call   102707 <vprintfmt>
	// null terminate the buffer
	*b.buf = '\0';
  102bea:	8b 45 ec             	mov    -0x14(%ebp),%eax
  102bed:	c6 00 00             	movb   $0x0,(%eax)
	return b.cnt;
  102bf0:	8b 45 f4             	mov    -0xc(%ebp),%eax
}
  102bf3:	c9                   	leave  
  102bf4:	c3                   	ret    
  102bf5:	00 00                	add    %al,(%eax)
	...

00102bf8 <strlen>:
 * @s:		the input string
 *
 * The strlen() function returns the length of string @s.
 * */
size_t
strlen(const char *s) {
  102bf8:	55                   	push   %ebp
  102bf9:	89 e5                	mov    %esp,%ebp
  102bfb:	83 ec 10             	sub    $0x10,%esp
	size_t cnt = 0;
  102bfe:	c7 45 fc 00 00 00 00 	movl   $0x0,-0x4(%ebp)
	while (*s ++ != '\0') {
  102c05:	eb 04                	jmp    102c0b <strlen+0x13>
		cnt ++;
  102c07:	83 45 fc 01          	addl   $0x1,-0x4(%ebp)
 * The strlen() function returns the length of string @s.
 * */
size_t
strlen(const char *s) {
	size_t cnt = 0;
	while (*s ++ != '\0') {
  102c0b:	8b 45 08             	mov    0x8(%ebp),%eax
  102c0e:	0f b6 00             	movzbl (%eax),%eax
  102c11:	84 c0                	test   %al,%al
  102c13:	0f 95 c0             	setne  %al
  102c16:	83 45 08 01          	addl   $0x1,0x8(%ebp)
  102c1a:	84 c0                	test   %al,%al
  102c1c:	75 e9                	jne    102c07 <strlen+0xf>
		cnt ++;
	}
	return cnt;
  102c1e:	8b 45 fc             	mov    -0x4(%ebp),%eax
}
  102c21:	c9                   	leave  
  102c22:	c3                   	ret    

00102c23 <strnlen>:
 * The return value is strlen(s), if that is less than @len, or
 * @len if there is no '\0' character among the first @len characters
 * pointed by @s.
 * */
size_t
strnlen(const char *s, size_t len) {
  102c23:	55                   	push   %ebp
  102c24:	89 e5                	mov    %esp,%ebp
  102c26:	83 ec 10             	sub    $0x10,%esp
	size_t cnt = 0;
  102c29:	c7 45 fc 00 00 00 00 	movl   $0x0,-0x4(%ebp)
	while (cnt < len && *s ++ != '\0') {
  102c30:	eb 04                	jmp    102c36 <strnlen+0x13>
		cnt ++;
  102c32:	83 45 fc 01          	addl   $0x1,-0x4(%ebp)
 * pointed by @s.
 * */
size_t
strnlen(const char *s, size_t len) {
	size_t cnt = 0;
	while (cnt < len && *s ++ != '\0') {
  102c36:	8b 45 fc             	mov    -0x4(%ebp),%eax
  102c39:	3b 45 0c             	cmp    0xc(%ebp),%eax
  102c3c:	73 13                	jae    102c51 <strnlen+0x2e>
  102c3e:	8b 45 08             	mov    0x8(%ebp),%eax
  102c41:	0f b6 00             	movzbl (%eax),%eax
  102c44:	84 c0                	test   %al,%al
  102c46:	0f 95 c0             	setne  %al
  102c49:	83 45 08 01          	addl   $0x1,0x8(%ebp)
  102c4d:	84 c0                	test   %al,%al
  102c4f:	75 e1                	jne    102c32 <strnlen+0xf>
		cnt ++;
	}
	return cnt;
  102c51:	8b 45 fc             	mov    -0x4(%ebp),%eax
}
  102c54:	c9                   	leave  
  102c55:	c3                   	ret    

00102c56 <strcpy>:
 * To avoid overflows, the size of array pointed by @dst should be long enough to
 * contain the same string as @src (including the terminating null character), and
 * should not overlap in memory with @src.
 * */
char *
strcpy(char *dst, const char *src) {
  102c56:	55                   	push   %ebp
  102c57:	89 e5                	mov    %esp,%ebp
  102c59:	57                   	push   %edi
  102c5a:	56                   	push   %esi
  102c5b:	83 ec 20             	sub    $0x20,%esp
  102c5e:	8b 45 08             	mov    0x8(%ebp),%eax
  102c61:	89 45 e8             	mov    %eax,-0x18(%ebp)
  102c64:	8b 45 0c             	mov    0xc(%ebp),%eax
  102c67:	89 45 e4             	mov    %eax,-0x1c(%ebp)
#ifndef __HAVE_ARCH_STRCPY
#define __HAVE_ARCH_STRCPY
static inline char *
__strcpy(char *dst, const char *src) {
	int d0, d1, d2;
	asm volatile (
  102c6a:	8b 55 e4             	mov    -0x1c(%ebp),%edx
  102c6d:	8b 45 e8             	mov    -0x18(%ebp),%eax
  102c70:	89 d1                	mov    %edx,%ecx
  102c72:	89 c2                	mov    %eax,%edx
  102c74:	89 ce                	mov    %ecx,%esi
  102c76:	89 d7                	mov    %edx,%edi
  102c78:	ac                   	lods   %ds:(%esi),%al
  102c79:	aa                   	stos   %al,%es:(%edi)
  102c7a:	84 c0                	test   %al,%al
  102c7c:	75 fa                	jne    102c78 <strcpy+0x22>
  102c7e:	89 fa                	mov    %edi,%edx
  102c80:	89 f1                	mov    %esi,%ecx
  102c82:	89 4d f4             	mov    %ecx,-0xc(%ebp)
  102c85:	89 55 f0             	mov    %edx,-0x10(%ebp)
  102c88:	89 45 ec             	mov    %eax,-0x14(%ebp)
			"stosb;"
			"testb %%al, %%al;"
			"jne 1b;"
			: "=&S" (d0), "=&D" (d1), "=&a" (d2)
			: "0" (src), "1" (dst) : "memory");
	return dst;
  102c8b:	8b 45 e8             	mov    -0x18(%ebp),%eax
	char *p = dst;
	while ((*p ++ = *src ++) != '\0')
		/* nothing */;
	return dst;
#endif /* __HAVE_ARCH_STRCPY */
}
  102c8e:	83 c4 20             	add    $0x20,%esp
  102c91:	5e                   	pop    %esi
  102c92:	5f                   	pop    %edi
  102c93:	5d                   	pop    %ebp
  102c94:	c3                   	ret    

00102c95 <strncpy>:
 * @len:	maximum number of characters to be copied from @src
 *
 * The return value is @dst
 * */
char *
strncpy(char *dst, const char *src, size_t len) {
  102c95:	55                   	push   %ebp
  102c96:	89 e5                	mov    %esp,%ebp
  102c98:	83 ec 10             	sub    $0x10,%esp
	char *p = dst;
  102c9b:	8b 45 08             	mov    0x8(%ebp),%eax
  102c9e:	89 45 fc             	mov    %eax,-0x4(%ebp)
	while (len > 0) {
  102ca1:	eb 21                	jmp    102cc4 <strncpy+0x2f>
		if ((*p = *src) != '\0') {
  102ca3:	8b 45 0c             	mov    0xc(%ebp),%eax
  102ca6:	0f b6 10             	movzbl (%eax),%edx
  102ca9:	8b 45 fc             	mov    -0x4(%ebp),%eax
  102cac:	88 10                	mov    %dl,(%eax)
  102cae:	8b 45 fc             	mov    -0x4(%ebp),%eax
  102cb1:	0f b6 00             	movzbl (%eax),%eax
  102cb4:	84 c0                	test   %al,%al
  102cb6:	74 04                	je     102cbc <strncpy+0x27>
			src ++;
  102cb8:	83 45 0c 01          	addl   $0x1,0xc(%ebp)
		}
		p ++, len --;
  102cbc:	83 45 fc 01          	addl   $0x1,-0x4(%ebp)
  102cc0:	83 6d 10 01          	subl   $0x1,0x10(%ebp)
 * The return value is @dst
 * */
char *
strncpy(char *dst, const char *src, size_t len) {
	char *p = dst;
	while (len > 0) {
  102cc4:	83 7d 10 00          	cmpl   $0x0,0x10(%ebp)
  102cc8:	75 d9                	jne    102ca3 <strncpy+0xe>
		if ((*p = *src) != '\0') {
			src ++;
		}
		p ++, len --;
	}
	return dst;
  102cca:	8b 45 08             	mov    0x8(%ebp),%eax
}
  102ccd:	c9                   	leave  
  102cce:	c3                   	ret    

00102ccf <strcmp>:
 * - A value greater than zero indicates that the first character that does
 *   not match has a greater value in @s1 than in @s2;
 * - And a value less than zero indicates the opposite.
 * */
int
strcmp(const char *s1, const char *s2) {
  102ccf:	55                   	push   %ebp
  102cd0:	89 e5                	mov    %esp,%ebp
  102cd2:	57                   	push   %edi
  102cd3:	56                   	push   %esi
  102cd4:	83 ec 20             	sub    $0x20,%esp
  102cd7:	8b 45 08             	mov    0x8(%ebp),%eax
  102cda:	89 45 e8             	mov    %eax,-0x18(%ebp)
  102cdd:	8b 45 0c             	mov    0xc(%ebp),%eax
  102ce0:	89 45 e4             	mov    %eax,-0x1c(%ebp)
#ifndef __HAVE_ARCH_STRCMP
#define __HAVE_ARCH_STRCMP
static inline int
__strcmp(const char *s1, const char *s2) {
	int d0, d1, ret;
	asm volatile (
  102ce3:	8b 55 e8             	mov    -0x18(%ebp),%edx
  102ce6:	8b 45 e4             	mov    -0x1c(%ebp),%eax
  102ce9:	89 d1                	mov    %edx,%ecx
  102ceb:	89 c2                	mov    %eax,%edx
  102ced:	89 ce                	mov    %ecx,%esi
  102cef:	89 d7                	mov    %edx,%edi
  102cf1:	ac                   	lods   %ds:(%esi),%al
  102cf2:	ae                   	scas   %es:(%edi),%al
  102cf3:	75 08                	jne    102cfd <strcmp+0x2e>
  102cf5:	84 c0                	test   %al,%al
  102cf7:	75 f8                	jne    102cf1 <strcmp+0x22>
  102cf9:	31 c0                	xor    %eax,%eax
  102cfb:	eb 04                	jmp    102d01 <strcmp+0x32>
  102cfd:	19 c0                	sbb    %eax,%eax
  102cff:	0c 01                	or     $0x1,%al
  102d01:	89 fa                	mov    %edi,%edx
  102d03:	89 f1                	mov    %esi,%ecx
  102d05:	89 45 ec             	mov    %eax,-0x14(%ebp)
  102d08:	89 4d f4             	mov    %ecx,-0xc(%ebp)
  102d0b:	89 55 f0             	mov    %edx,-0x10(%ebp)
			"orb $1, %%al;"
			"3:"
			: "=a" (ret), "=&S" (d0), "=&D" (d1)
			: "1" (s1), "2" (s2)
			: "memory");
	return ret;
  102d0e:	8b 45 ec             	mov    -0x14(%ebp),%eax
	while (*s1 != '\0' && *s1 == *s2) {
		s1 ++, s2 ++;
	}
	return (int)((unsigned char)*s1 - (unsigned char)*s2);
#endif /* __HAVE_ARCH_STRCMP */
}
  102d11:	83 c4 20             	add    $0x20,%esp
  102d14:	5e                   	pop    %esi
  102d15:	5f                   	pop    %edi
  102d16:	5d                   	pop    %ebp
  102d17:	c3                   	ret    

00102d18 <strncmp>:
 * they are equal to each other, it continues with the following pairs until
 * the characters differ, until a terminating null-character is reached, or
 * until @n characters match in both strings, whichever happens first.
 * */
int
strncmp(const char *s1, const char *s2, size_t n) {
  102d18:	55                   	push   %ebp
  102d19:	89 e5                	mov    %esp,%ebp
	while (n > 0 && *s1 != '\0' && *s1 == *s2) {
  102d1b:	eb 0c                	jmp    102d29 <strncmp+0x11>
		n --, s1 ++, s2 ++;
  102d1d:	83 6d 10 01          	subl   $0x1,0x10(%ebp)
  102d21:	83 45 08 01          	addl   $0x1,0x8(%ebp)
  102d25:	83 45 0c 01          	addl   $0x1,0xc(%ebp)
 * the characters differ, until a terminating null-character is reached, or
 * until @n characters match in both strings, whichever happens first.
 * */
int
strncmp(const char *s1, const char *s2, size_t n) {
	while (n > 0 && *s1 != '\0' && *s1 == *s2) {
  102d29:	83 7d 10 00          	cmpl   $0x0,0x10(%ebp)
  102d2d:	74 1a                	je     102d49 <strncmp+0x31>
  102d2f:	8b 45 08             	mov    0x8(%ebp),%eax
  102d32:	0f b6 00             	movzbl (%eax),%eax
  102d35:	84 c0                	test   %al,%al
  102d37:	74 10                	je     102d49 <strncmp+0x31>
  102d39:	8b 45 08             	mov    0x8(%ebp),%eax
  102d3c:	0f b6 10             	movzbl (%eax),%edx
  102d3f:	8b 45 0c             	mov    0xc(%ebp),%eax
  102d42:	0f b6 00             	movzbl (%eax),%eax
  102d45:	38 c2                	cmp    %al,%dl
  102d47:	74 d4                	je     102d1d <strncmp+0x5>
		n --, s1 ++, s2 ++;
	}
	return (n == 0) ? 0 : (int)((unsigned char)*s1 - (unsigned char)*s2);
  102d49:	83 7d 10 00          	cmpl   $0x0,0x10(%ebp)
  102d4d:	74 1a                	je     102d69 <strncmp+0x51>
  102d4f:	8b 45 08             	mov    0x8(%ebp),%eax
  102d52:	0f b6 00             	movzbl (%eax),%eax
  102d55:	0f b6 d0             	movzbl %al,%edx
  102d58:	8b 45 0c             	mov    0xc(%ebp),%eax
  102d5b:	0f b6 00             	movzbl (%eax),%eax
  102d5e:	0f b6 c0             	movzbl %al,%eax
  102d61:	89 d1                	mov    %edx,%ecx
  102d63:	29 c1                	sub    %eax,%ecx
  102d65:	89 c8                	mov    %ecx,%eax
  102d67:	eb 05                	jmp    102d6e <strncmp+0x56>
  102d69:	b8 00 00 00 00       	mov    $0x0,%eax
}
  102d6e:	5d                   	pop    %ebp
  102d6f:	c3                   	ret    

00102d70 <strchr>:
 *
 * The strchr() function returns a pointer to the first occurrence of
 * character in @s. If the value is not found, the function returns 'NULL'.
 * */
char *
strchr(const char *s, char c) {
  102d70:	55                   	push   %ebp
  102d71:	89 e5                	mov    %esp,%ebp
  102d73:	83 ec 04             	sub    $0x4,%esp
  102d76:	8b 45 0c             	mov    0xc(%ebp),%eax
  102d79:	88 45 fc             	mov    %al,-0x4(%ebp)
	while (*s != '\0') {
  102d7c:	eb 14                	jmp    102d92 <strchr+0x22>
		if (*s == c) {
  102d7e:	8b 45 08             	mov    0x8(%ebp),%eax
  102d81:	0f b6 00             	movzbl (%eax),%eax
  102d84:	3a 45 fc             	cmp    -0x4(%ebp),%al
  102d87:	75 05                	jne    102d8e <strchr+0x1e>
			return (char *)s;
  102d89:	8b 45 08             	mov    0x8(%ebp),%eax
  102d8c:	eb 13                	jmp    102da1 <strchr+0x31>
		}
		s ++;
  102d8e:	83 45 08 01          	addl   $0x1,0x8(%ebp)
 * The strchr() function returns a pointer to the first occurrence of
 * character in @s. If the value is not found, the function returns 'NULL'.
 * */
char *
strchr(const char *s, char c) {
	while (*s != '\0') {
  102d92:	8b 45 08             	mov    0x8(%ebp),%eax
  102d95:	0f b6 00             	movzbl (%eax),%eax
  102d98:	84 c0                	test   %al,%al
  102d9a:	75 e2                	jne    102d7e <strchr+0xe>
		if (*s == c) {
			return (char *)s;
		}
		s ++;
	}
	return NULL;
  102d9c:	b8 00 00 00 00       	mov    $0x0,%eax
}
  102da1:	c9                   	leave  
  102da2:	c3                   	ret    

00102da3 <strfind>:
 * The strfind() function is like strchr() except that if @c is
 * not found in @s, then it returns a pointer to the null byte at the
 * end of @s, rather than 'NULL'.
 * */
char *
strfind(const char *s, char c) {
  102da3:	55                   	push   %ebp
  102da4:	89 e5                	mov    %esp,%ebp
  102da6:	83 ec 04             	sub    $0x4,%esp
  102da9:	8b 45 0c             	mov    0xc(%ebp),%eax
  102dac:	88 45 fc             	mov    %al,-0x4(%ebp)
	while (*s != '\0') {
  102daf:	eb 0f                	jmp    102dc0 <strfind+0x1d>
		if (*s == c) {
  102db1:	8b 45 08             	mov    0x8(%ebp),%eax
  102db4:	0f b6 00             	movzbl (%eax),%eax
  102db7:	3a 45 fc             	cmp    -0x4(%ebp),%al
  102dba:	74 10                	je     102dcc <strfind+0x29>
			break;
		}
		s ++;
  102dbc:	83 45 08 01          	addl   $0x1,0x8(%ebp)
 * not found in @s, then it returns a pointer to the null byte at the
 * end of @s, rather than 'NULL'.
 * */
char *
strfind(const char *s, char c) {
	while (*s != '\0') {
  102dc0:	8b 45 08             	mov    0x8(%ebp),%eax
  102dc3:	0f b6 00             	movzbl (%eax),%eax
  102dc6:	84 c0                	test   %al,%al
  102dc8:	75 e7                	jne    102db1 <strfind+0xe>
  102dca:	eb 01                	jmp    102dcd <strfind+0x2a>
		if (*s == c) {
			break;
  102dcc:	90                   	nop
		}
		s ++;
	}
	return (char *)s;
  102dcd:	8b 45 08             	mov    0x8(%ebp),%eax
}
  102dd0:	c9                   	leave  
  102dd1:	c3                   	ret    

00102dd2 <strtol>:
 * an optional "0x" or "0X" prefix.
 *
 * The strtol() function returns the converted integral number as a long int value.
 * */
long
strtol(const char *s, char **endptr, int base) {
  102dd2:	55                   	push   %ebp
  102dd3:	89 e5                	mov    %esp,%ebp
  102dd5:	83 ec 10             	sub    $0x10,%esp
	int neg = 0;
  102dd8:	c7 45 f4 00 00 00 00 	movl   $0x0,-0xc(%ebp)
	long val = 0;
  102ddf:	c7 45 f8 00 00 00 00 	movl   $0x0,-0x8(%ebp)

	// gobble initial whitespace
	while (*s == ' ' || *s == '\t') {
  102de6:	eb 04                	jmp    102dec <strtol+0x1a>
		s ++;
  102de8:	83 45 08 01          	addl   $0x1,0x8(%ebp)
strtol(const char *s, char **endptr, int base) {
	int neg = 0;
	long val = 0;

	// gobble initial whitespace
	while (*s == ' ' || *s == '\t') {
  102dec:	8b 45 08             	mov    0x8(%ebp),%eax
  102def:	0f b6 00             	movzbl (%eax),%eax
  102df2:	3c 20                	cmp    $0x20,%al
  102df4:	74 f2                	je     102de8 <strtol+0x16>
  102df6:	8b 45 08             	mov    0x8(%ebp),%eax
  102df9:	0f b6 00             	movzbl (%eax),%eax
  102dfc:	3c 09                	cmp    $0x9,%al
  102dfe:	74 e8                	je     102de8 <strtol+0x16>
		s ++;
	}

	// plus/minus sign
	if (*s == '+') {
  102e00:	8b 45 08             	mov    0x8(%ebp),%eax
  102e03:	0f b6 00             	movzbl (%eax),%eax
  102e06:	3c 2b                	cmp    $0x2b,%al
  102e08:	75 06                	jne    102e10 <strtol+0x3e>
		s ++;
  102e0a:	83 45 08 01          	addl   $0x1,0x8(%ebp)
  102e0e:	eb 15                	jmp    102e25 <strtol+0x53>
	}
	else if (*s == '-') {
  102e10:	8b 45 08             	mov    0x8(%ebp),%eax
  102e13:	0f b6 00             	movzbl (%eax),%eax
  102e16:	3c 2d                	cmp    $0x2d,%al
  102e18:	75 0b                	jne    102e25 <strtol+0x53>
		s ++, neg = 1;
  102e1a:	83 45 08 01          	addl   $0x1,0x8(%ebp)
  102e1e:	c7 45 f4 01 00 00 00 	movl   $0x1,-0xc(%ebp)
	}

	// hex or octal base prefix
	if ((base == 0 || base == 16) && (s[0] == '0' && s[1] == 'x')) {
  102e25:	83 7d 10 00          	cmpl   $0x0,0x10(%ebp)
  102e29:	74 06                	je     102e31 <strtol+0x5f>
  102e2b:	83 7d 10 10          	cmpl   $0x10,0x10(%ebp)
  102e2f:	75 24                	jne    102e55 <strtol+0x83>
  102e31:	8b 45 08             	mov    0x8(%ebp),%eax
  102e34:	0f b6 00             	movzbl (%eax),%eax
  102e37:	3c 30                	cmp    $0x30,%al
  102e39:	75 1a                	jne    102e55 <strtol+0x83>
  102e3b:	8b 45 08             	mov    0x8(%ebp),%eax
  102e3e:	83 c0 01             	add    $0x1,%eax
  102e41:	0f b6 00             	movzbl (%eax),%eax
  102e44:	3c 78                	cmp    $0x78,%al
  102e46:	75 0d                	jne    102e55 <strtol+0x83>
		s += 2, base = 16;
  102e48:	83 45 08 02          	addl   $0x2,0x8(%ebp)
  102e4c:	c7 45 10 10 00 00 00 	movl   $0x10,0x10(%ebp)
	else if (*s == '-') {
		s ++, neg = 1;
	}

	// hex or octal base prefix
	if ((base == 0 || base == 16) && (s[0] == '0' && s[1] == 'x')) {
  102e53:	eb 2a                	jmp    102e7f <strtol+0xad>
		s += 2, base = 16;
	}
	else if (base == 0 && s[0] == '0') {
  102e55:	83 7d 10 00          	cmpl   $0x0,0x10(%ebp)
  102e59:	75 17                	jne    102e72 <strtol+0xa0>
  102e5b:	8b 45 08             	mov    0x8(%ebp),%eax
  102e5e:	0f b6 00             	movzbl (%eax),%eax
  102e61:	3c 30                	cmp    $0x30,%al
  102e63:	75 0d                	jne    102e72 <strtol+0xa0>
		s ++, base = 8;
  102e65:	83 45 08 01          	addl   $0x1,0x8(%ebp)
  102e69:	c7 45 10 08 00 00 00 	movl   $0x8,0x10(%ebp)

	// hex or octal base prefix
	if ((base == 0 || base == 16) && (s[0] == '0' && s[1] == 'x')) {
		s += 2, base = 16;
	}
	else if (base == 0 && s[0] == '0') {
  102e70:	eb 0d                	jmp    102e7f <strtol+0xad>
		s ++, base = 8;
	}
	else if (base == 0) {
  102e72:	83 7d 10 00          	cmpl   $0x0,0x10(%ebp)
  102e76:	75 07                	jne    102e7f <strtol+0xad>
		base = 10;
  102e78:	c7 45 10 0a 00 00 00 	movl   $0xa,0x10(%ebp)

	// digits
	while (1) {
		int dig;

		if (*s >= '0' && *s <= '9') {
  102e7f:	8b 45 08             	mov    0x8(%ebp),%eax
  102e82:	0f b6 00             	movzbl (%eax),%eax
  102e85:	3c 2f                	cmp    $0x2f,%al
  102e87:	7e 1b                	jle    102ea4 <strtol+0xd2>
  102e89:	8b 45 08             	mov    0x8(%ebp),%eax
  102e8c:	0f b6 00             	movzbl (%eax),%eax
  102e8f:	3c 39                	cmp    $0x39,%al
  102e91:	7f 11                	jg     102ea4 <strtol+0xd2>
			dig = *s - '0';
  102e93:	8b 45 08             	mov    0x8(%ebp),%eax
  102e96:	0f b6 00             	movzbl (%eax),%eax
  102e99:	0f be c0             	movsbl %al,%eax
  102e9c:	83 e8 30             	sub    $0x30,%eax
  102e9f:	89 45 fc             	mov    %eax,-0x4(%ebp)

	// digits
	while (1) {
		int dig;

		if (*s >= '0' && *s <= '9') {
  102ea2:	eb 48                	jmp    102eec <strtol+0x11a>
			dig = *s - '0';
		}
		else if (*s >= 'a' && *s <= 'z') {
  102ea4:	8b 45 08             	mov    0x8(%ebp),%eax
  102ea7:	0f b6 00             	movzbl (%eax),%eax
  102eaa:	3c 60                	cmp    $0x60,%al
  102eac:	7e 1b                	jle    102ec9 <strtol+0xf7>
  102eae:	8b 45 08             	mov    0x8(%ebp),%eax
  102eb1:	0f b6 00             	movzbl (%eax),%eax
  102eb4:	3c 7a                	cmp    $0x7a,%al
  102eb6:	7f 11                	jg     102ec9 <strtol+0xf7>
			dig = *s - 'a' + 10;
  102eb8:	8b 45 08             	mov    0x8(%ebp),%eax
  102ebb:	0f b6 00             	movzbl (%eax),%eax
  102ebe:	0f be c0             	movsbl %al,%eax
  102ec1:	83 e8 57             	sub    $0x57,%eax
  102ec4:	89 45 fc             	mov    %eax,-0x4(%ebp)
		int dig;

		if (*s >= '0' && *s <= '9') {
			dig = *s - '0';
		}
		else if (*s >= 'a' && *s <= 'z') {
  102ec7:	eb 23                	jmp    102eec <strtol+0x11a>
			dig = *s - 'a' + 10;
		}
		else if (*s >= 'A' && *s <= 'Z') {
  102ec9:	8b 45 08             	mov    0x8(%ebp),%eax
  102ecc:	0f b6 00             	movzbl (%eax),%eax
  102ecf:	3c 40                	cmp    $0x40,%al
  102ed1:	7e 38                	jle    102f0b <strtol+0x139>
  102ed3:	8b 45 08             	mov    0x8(%ebp),%eax
  102ed6:	0f b6 00             	movzbl (%eax),%eax
  102ed9:	3c 5a                	cmp    $0x5a,%al
  102edb:	7f 2e                	jg     102f0b <strtol+0x139>
			dig = *s - 'A' + 10;
  102edd:	8b 45 08             	mov    0x8(%ebp),%eax
  102ee0:	0f b6 00             	movzbl (%eax),%eax
  102ee3:	0f be c0             	movsbl %al,%eax
  102ee6:	83 e8 37             	sub    $0x37,%eax
  102ee9:	89 45 fc             	mov    %eax,-0x4(%ebp)
		}
		else {
			break;
		}
		if (dig >= base) {
  102eec:	8b 45 fc             	mov    -0x4(%ebp),%eax
  102eef:	3b 45 10             	cmp    0x10(%ebp),%eax
  102ef2:	7d 16                	jge    102f0a <strtol+0x138>
			break;
		}
		s ++, val = (val * base) + dig;
  102ef4:	83 45 08 01          	addl   $0x1,0x8(%ebp)
  102ef8:	8b 45 f8             	mov    -0x8(%ebp),%eax
  102efb:	0f af 45 10          	imul   0x10(%ebp),%eax
  102eff:	03 45 fc             	add    -0x4(%ebp),%eax
  102f02:	89 45 f8             	mov    %eax,-0x8(%ebp)
		// we don't properly detect overflow!
	}
  102f05:	e9 75 ff ff ff       	jmp    102e7f <strtol+0xad>
		}
		else {
			break;
		}
		if (dig >= base) {
			break;
  102f0a:	90                   	nop
		}
		s ++, val = (val * base) + dig;
		// we don't properly detect overflow!
	}

	if (endptr) {
  102f0b:	83 7d 0c 00          	cmpl   $0x0,0xc(%ebp)
  102f0f:	74 08                	je     102f19 <strtol+0x147>
		*endptr = (char *) s;
  102f11:	8b 45 0c             	mov    0xc(%ebp),%eax
  102f14:	8b 55 08             	mov    0x8(%ebp),%edx
  102f17:	89 10                	mov    %edx,(%eax)
	}
	return (neg ? -val : val);
  102f19:	83 7d f4 00          	cmpl   $0x0,-0xc(%ebp)
  102f1d:	74 07                	je     102f26 <strtol+0x154>
  102f1f:	8b 45 f8             	mov    -0x8(%ebp),%eax
  102f22:	f7 d8                	neg    %eax
  102f24:	eb 03                	jmp    102f29 <strtol+0x157>
  102f26:	8b 45 f8             	mov    -0x8(%ebp),%eax
}
  102f29:	c9                   	leave  
  102f2a:	c3                   	ret    

00102f2b <memset>:
 * @n:		number of bytes to be set to the value
 *
 * The memset() function returns @s.
 * */
void *
memset(void *s, char c, size_t n) {
  102f2b:	55                   	push   %ebp
  102f2c:	89 e5                	mov    %esp,%ebp
  102f2e:	57                   	push   %edi
  102f2f:	83 ec 24             	sub    $0x24,%esp
  102f32:	8b 45 0c             	mov    0xc(%ebp),%eax
  102f35:	88 45 d8             	mov    %al,-0x28(%ebp)
#ifdef __HAVE_ARCH_MEMSET
	return __memset(s, c, n);
  102f38:	0f be 45 d8          	movsbl -0x28(%ebp),%eax
  102f3c:	8b 55 08             	mov    0x8(%ebp),%edx
  102f3f:	89 55 f0             	mov    %edx,-0x10(%ebp)
  102f42:	88 45 ef             	mov    %al,-0x11(%ebp)
  102f45:	8b 45 10             	mov    0x10(%ebp),%eax
  102f48:	89 45 e8             	mov    %eax,-0x18(%ebp)
#ifndef __HAVE_ARCH_MEMSET
#define __HAVE_ARCH_MEMSET
static inline void *
__memset(void *s, char c, size_t n) {
	int d0, d1;
	asm volatile (
  102f4b:	8b 4d e8             	mov    -0x18(%ebp),%ecx
  102f4e:	0f b6 45 ef          	movzbl -0x11(%ebp),%eax
  102f52:	8b 55 f0             	mov    -0x10(%ebp),%edx
  102f55:	89 d7                	mov    %edx,%edi
  102f57:	f3 aa                	rep stos %al,%es:(%edi)
  102f59:	89 fa                	mov    %edi,%edx
  102f5b:	89 4d f8             	mov    %ecx,-0x8(%ebp)
  102f5e:	89 55 f4             	mov    %edx,-0xc(%ebp)
			"rep; stosb;"
			: "=&c" (d0), "=&D" (d1)
			: "0" (n), "a" (c), "1" (s)
			: "memory");
	return s;
  102f61:	8b 45 f0             	mov    -0x10(%ebp),%eax
	while (n -- > 0) {
		*p ++ = c;
	}
	return s;
#endif /* __HAVE_ARCH_MEMSET */
}
  102f64:	83 c4 24             	add    $0x24,%esp
  102f67:	5f                   	pop    %edi
  102f68:	5d                   	pop    %ebp
  102f69:	c3                   	ret    

00102f6a <memmove>:
 * @n:		number of bytes to copy
 *
 * The memmove() function returns @dst.
 * */
void *
memmove(void *dst, const void *src, size_t n) {
  102f6a:	55                   	push   %ebp
  102f6b:	89 e5                	mov    %esp,%ebp
  102f6d:	57                   	push   %edi
  102f6e:	56                   	push   %esi
  102f6f:	83 ec 30             	sub    $0x30,%esp
  102f72:	8b 45 08             	mov    0x8(%ebp),%eax
  102f75:	89 45 d0             	mov    %eax,-0x30(%ebp)
  102f78:	8b 45 0c             	mov    0xc(%ebp),%eax
  102f7b:	89 45 cc             	mov    %eax,-0x34(%ebp)
  102f7e:	8b 45 10             	mov    0x10(%ebp),%eax
  102f81:	89 45 c8             	mov    %eax,-0x38(%ebp)

#ifndef __HAVE_ARCH_MEMMOVE
#define __HAVE_ARCH_MEMMOVE
static inline void *
__memmove(void *dst, const void *src, size_t n) {
	if (dst < src) {
  102f84:	8b 45 d0             	mov    -0x30(%ebp),%eax
  102f87:	3b 45 cc             	cmp    -0x34(%ebp),%eax
  102f8a:	73 42                	jae    102fce <memmove+0x64>
  102f8c:	8b 45 d0             	mov    -0x30(%ebp),%eax
  102f8f:	89 45 e8             	mov    %eax,-0x18(%ebp)
  102f92:	8b 45 cc             	mov    -0x34(%ebp),%eax
  102f95:	89 45 e4             	mov    %eax,-0x1c(%ebp)
  102f98:	8b 45 c8             	mov    -0x38(%ebp),%eax
  102f9b:	89 45 e0             	mov    %eax,-0x20(%ebp)
			"andl $3, %%ecx;"
			"jz 1f;"
			"rep; movsb;"
			"1:"
			: "=&c" (d0), "=&D" (d1), "=&S" (d2)
			: "0" (n / 4), "g" (n), "1" (dst), "2" (src)
  102f9e:	8b 45 e0             	mov    -0x20(%ebp),%eax
  102fa1:	89 c1                	mov    %eax,%ecx
  102fa3:	c1 e9 02             	shr    $0x2,%ecx
#ifndef __HAVE_ARCH_MEMCPY
#define __HAVE_ARCH_MEMCPY
static inline void *
__memcpy(void *dst, const void *src, size_t n) {
	int d0, d1, d2;
	asm volatile (
  102fa6:	8b 55 e8             	mov    -0x18(%ebp),%edx
  102fa9:	8b 45 e4             	mov    -0x1c(%ebp),%eax
  102fac:	89 d7                	mov    %edx,%edi
  102fae:	89 c6                	mov    %eax,%esi
  102fb0:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)
  102fb2:	8b 4d e0             	mov    -0x20(%ebp),%ecx
  102fb5:	83 e1 03             	and    $0x3,%ecx
  102fb8:	74 02                	je     102fbc <memmove+0x52>
  102fba:	f3 a4                	rep movsb %ds:(%esi),%es:(%edi)
  102fbc:	89 f0                	mov    %esi,%eax
  102fbe:	89 fa                	mov    %edi,%edx
  102fc0:	89 4d f4             	mov    %ecx,-0xc(%ebp)
  102fc3:	89 55 f0             	mov    %edx,-0x10(%ebp)
  102fc6:	89 45 ec             	mov    %eax,-0x14(%ebp)
			"rep; movsb;"
			"1:"
			: "=&c" (d0), "=&D" (d1), "=&S" (d2)
			: "0" (n / 4), "g" (n), "1" (dst), "2" (src)
			: "memory");
	return dst;
  102fc9:	8b 45 e8             	mov    -0x18(%ebp),%eax
  102fcc:	eb 2f                	jmp    102ffd <memmove+0x93>
	asm volatile (
			"std;"
			"rep; movsb;"
			"cld;"
			: "=&c" (d0), "=&S" (d1), "=&D" (d2)
			: "0" (n), "1" (n - 1 + src), "2" (n - 1 + dst)
  102fce:	8b 45 c8             	mov    -0x38(%ebp),%eax
  102fd1:	83 e8 01             	sub    $0x1,%eax
  102fd4:	89 c2                	mov    %eax,%edx
  102fd6:	03 55 cc             	add    -0x34(%ebp),%edx
  102fd9:	8b 45 c8             	mov    -0x38(%ebp),%eax
  102fdc:	83 e8 01             	sub    $0x1,%eax
  102fdf:	03 45 d0             	add    -0x30(%ebp),%eax
__memmove(void *dst, const void *src, size_t n) {
	if (dst < src) {
		return __memcpy(dst, src, n);
	}
	int d0, d1, d2;
	asm volatile (
  102fe2:	8b 4d c8             	mov    -0x38(%ebp),%ecx
  102fe5:	89 d6                	mov    %edx,%esi
  102fe7:	89 c7                	mov    %eax,%edi
  102fe9:	fd                   	std    
  102fea:	f3 a4                	rep movsb %ds:(%esi),%es:(%edi)
  102fec:	fc                   	cld    
  102fed:	89 f8                	mov    %edi,%eax
  102fef:	89 f2                	mov    %esi,%edx
  102ff1:	89 4d dc             	mov    %ecx,-0x24(%ebp)
  102ff4:	89 55 d8             	mov    %edx,-0x28(%ebp)
  102ff7:	89 45 d4             	mov    %eax,-0x2c(%ebp)
			"rep; movsb;"
			"cld;"
			: "=&c" (d0), "=&S" (d1), "=&D" (d2)
			: "0" (n), "1" (n - 1 + src), "2" (n - 1 + dst)
			: "memory");
	return dst;
  102ffa:	8b 45 d0             	mov    -0x30(%ebp),%eax
			*d ++ = *s ++;
		}
	}
	return dst;
#endif /* __HAVE_ARCH_MEMMOVE */
}
  102ffd:	83 c4 30             	add    $0x30,%esp
  103000:	5e                   	pop    %esi
  103001:	5f                   	pop    %edi
  103002:	5d                   	pop    %ebp
  103003:	c3                   	ret    

00103004 <memcpy>:
 * it always copies exactly @n bytes. To avoid overflows, the size of arrays pointed
 * by both @src and @dst, should be at least @n bytes, and should not overlap
 * (for overlapping memory area, memmove is a safer approach).
 * */
void *
memcpy(void *dst, const void *src, size_t n) {
  103004:	55                   	push   %ebp
  103005:	89 e5                	mov    %esp,%ebp
  103007:	57                   	push   %edi
  103008:	56                   	push   %esi
  103009:	83 ec 20             	sub    $0x20,%esp
  10300c:	8b 45 08             	mov    0x8(%ebp),%eax
  10300f:	89 45 e8             	mov    %eax,-0x18(%ebp)
  103012:	8b 45 0c             	mov    0xc(%ebp),%eax
  103015:	89 45 e4             	mov    %eax,-0x1c(%ebp)
  103018:	8b 45 10             	mov    0x10(%ebp),%eax
  10301b:	89 45 e0             	mov    %eax,-0x20(%ebp)
			"andl $3, %%ecx;"
			"jz 1f;"
			"rep; movsb;"
			"1:"
			: "=&c" (d0), "=&D" (d1), "=&S" (d2)
			: "0" (n / 4), "g" (n), "1" (dst), "2" (src)
  10301e:	8b 45 e0             	mov    -0x20(%ebp),%eax
  103021:	89 c1                	mov    %eax,%ecx
  103023:	c1 e9 02             	shr    $0x2,%ecx
#ifndef __HAVE_ARCH_MEMCPY
#define __HAVE_ARCH_MEMCPY
static inline void *
__memcpy(void *dst, const void *src, size_t n) {
	int d0, d1, d2;
	asm volatile (
  103026:	8b 55 e8             	mov    -0x18(%ebp),%edx
  103029:	8b 45 e4             	mov    -0x1c(%ebp),%eax
  10302c:	89 d7                	mov    %edx,%edi
  10302e:	89 c6                	mov    %eax,%esi
  103030:	f3 a5                	rep movsl %ds:(%esi),%es:(%edi)
  103032:	8b 4d e0             	mov    -0x20(%ebp),%ecx
  103035:	83 e1 03             	and    $0x3,%ecx
  103038:	74 02                	je     10303c <memcpy+0x38>
  10303a:	f3 a4                	rep movsb %ds:(%esi),%es:(%edi)
  10303c:	89 f0                	mov    %esi,%eax
  10303e:	89 fa                	mov    %edi,%edx
  103040:	89 4d f4             	mov    %ecx,-0xc(%ebp)
  103043:	89 55 f0             	mov    %edx,-0x10(%ebp)
  103046:	89 45 ec             	mov    %eax,-0x14(%ebp)
			"rep; movsb;"
			"1:"
			: "=&c" (d0), "=&D" (d1), "=&S" (d2)
			: "0" (n / 4), "g" (n), "1" (dst), "2" (src)
			: "memory");
	return dst;
  103049:	8b 45 e8             	mov    -0x18(%ebp),%eax
	while (n -- > 0) {
		*d ++ = *s ++;
	}
	return dst;
#endif /* __HAVE_ARCH_MEMCPY */
}
  10304c:	83 c4 20             	add    $0x20,%esp
  10304f:	5e                   	pop    %esi
  103050:	5f                   	pop    %edi
  103051:	5d                   	pop    %ebp
  103052:	c3                   	ret    

00103053 <memcmp>:
 *   match in both memory blocks has a greater value in @v1 than in @v2
 *   as if evaluated as unsigned char values;
 * - And a value less than zero indicates the opposite.
 * */
int
memcmp(const void *v1, const void *v2, size_t n) {
  103053:	55                   	push   %ebp
  103054:	89 e5                	mov    %esp,%ebp
  103056:	83 ec 10             	sub    $0x10,%esp
	const char *s1 = (const char *)v1;
  103059:	8b 45 08             	mov    0x8(%ebp),%eax
  10305c:	89 45 f8             	mov    %eax,-0x8(%ebp)
	const char *s2 = (const char *)v2;
  10305f:	8b 45 0c             	mov    0xc(%ebp),%eax
  103062:	89 45 fc             	mov    %eax,-0x4(%ebp)
	while (n -- > 0) {
  103065:	eb 32                	jmp    103099 <memcmp+0x46>
		if (*s1 != *s2) {
  103067:	8b 45 f8             	mov    -0x8(%ebp),%eax
  10306a:	0f b6 10             	movzbl (%eax),%edx
  10306d:	8b 45 fc             	mov    -0x4(%ebp),%eax
  103070:	0f b6 00             	movzbl (%eax),%eax
  103073:	38 c2                	cmp    %al,%dl
  103075:	74 1a                	je     103091 <memcmp+0x3e>
			return (int)((unsigned char)*s1 - (unsigned char)*s2);
  103077:	8b 45 f8             	mov    -0x8(%ebp),%eax
  10307a:	0f b6 00             	movzbl (%eax),%eax
  10307d:	0f b6 d0             	movzbl %al,%edx
  103080:	8b 45 fc             	mov    -0x4(%ebp),%eax
  103083:	0f b6 00             	movzbl (%eax),%eax
  103086:	0f b6 c0             	movzbl %al,%eax
  103089:	89 d1                	mov    %edx,%ecx
  10308b:	29 c1                	sub    %eax,%ecx
  10308d:	89 c8                	mov    %ecx,%eax
  10308f:	eb 1c                	jmp    1030ad <memcmp+0x5a>
		}
		s1 ++, s2 ++;
  103091:	83 45 f8 01          	addl   $0x1,-0x8(%ebp)
  103095:	83 45 fc 01          	addl   $0x1,-0x4(%ebp)
 * */
int
memcmp(const void *v1, const void *v2, size_t n) {
	const char *s1 = (const char *)v1;
	const char *s2 = (const char *)v2;
	while (n -- > 0) {
  103099:	83 7d 10 00          	cmpl   $0x0,0x10(%ebp)
  10309d:	0f 95 c0             	setne  %al
  1030a0:	83 6d 10 01          	subl   $0x1,0x10(%ebp)
  1030a4:	84 c0                	test   %al,%al
  1030a6:	75 bf                	jne    103067 <memcmp+0x14>
		if (*s1 != *s2) {
			return (int)((unsigned char)*s1 - (unsigned char)*s2);
		}
		s1 ++, s2 ++;
	}
	return 0;
  1030a8:	b8 00 00 00 00       	mov    $0x0,%eax
}
  1030ad:	c9                   	leave  
  1030ae:	c3                   	ret    
